Free Motion Capture for Everyone 💀✨
TypeScript
Jon/die better (#771)
jonmatthis615726350698
diff --git a/.gitignore b/.gitignoreindex c9a46bb3..3827234f 100644--- a/.gitignore+++ b/.gitignore@@ -161,3 +161,4 @@ realease/*pyapp-*/pyapp.zip.vite+*.zip\ No newline at end of filediff --git a/TESTING.md b/TESTING.mdnew file mode 100644index 00000000..24c70b5b--- /dev/null+++ b/TESTING.md@@ -0,0 +1,97 @@+# Testing++## Quick Start++```bash+# Backend (from repo root):+uv run poe test-all++# Frontend (from freemocap-ui/):+cd freemocap-ui+npm test+```++## Setup (one time)++```bash+# Backend (from repo root):+uv sync --group dev++# Frontend:+cd freemocap-ui+npm install+```++## Running Tests++### Backend (from repo root)++```bash+uv run poe test-all # All backend tests+uv run poe test-schema # Schema contract tests (field names, defaults)+uv run poe test-settings # SettingsManager unit tests (merge, patch, version)+uv run poe test-http # HTTP endpoint integration tests+uv run poe test-ws # WebSocket protocol tests+uv run poe test-e2e # End-to-end integration tests (HTTP + WebSocket round-trip)+uv run poe test-sync # All sync test files together (unit + E2E)+```++### Frontend (from freemocap-ui/)++```bash+cd freemocap-ui+npm test # Run once+npm run test:watch # Watch mode (re-runs on save)+```++### Nox (CI / multi-Python)++```bash+nox -s test # Backend on Python 3.11 + 3.12+nox -s test_sync # Just sync tests on 3.12+nox -s test_ui # Frontend (requires npm on PATH)+nox -s test_all # Backend + frontend on 3.12+nox -s coverage # Backend with coverage report+```++## Available poe tasks++Run `uv run poe --help` for the full list. Testing tasks:++| Task | What runs |+|---|---|+| `test-all` | All backend tests |+| `test-schema` | Schema contract: Pydantic ↔ TypeScript field names & defaults |+| `test-settings` | SettingsManager: merge, patch, version, async notify |+| `test-http` | HTTP endpoints: payload validation, settings sync |+| `test-ws` | WebSocket protocol: patch routing, relay push |+| `test-e2e` | End-to-end: HTTP → SettingsManager → WebSocket push round-trip |+| `test-sync` | All sync test files combined (unit + E2E) |++## What Each Test Layer Catches++| Layer | File | What breaks if this fails |+|---|---|---|+| **Schema contract** | `test_schema_contract.py` | Backend renamed a field but frontend still sends the old name. A default value changed on one side but not the other. |+| **SettingsManager** | `test_settings_manager.py` | `apply_patch` clobbers sibling config fields. Version doesn't bump so WebSocket never pushes. `_deep_merge` mutates its inputs. |+| **HTTP endpoints** | `test_http_config_endpoints.py` | Frontend thunk payload gets 422 (camelCase vs snake_case mismatch). Config update doesn't reach SettingsManager or pipelines. |+| **WebSocket protocol** | `test_websocket_settings_protocol.py` | `settings/patch` accepted but never synced to running pipelines. `settings/request` doesn't trigger a state push. Bad message type silently ignored. |+| **E2E HTTP** | `test_e2e_http_settings_sync.py` | Route prefix mounting wrong (double prefix, missing prefix). Cross-router updates clobber each other through shared SettingsManager. Frontend URL paths don't resolve. |+| **E2E WebSocket** | `test_e2e_websocket_settings_sync.py` | HTTP POST doesn't trigger WebSocket state push. WebSocket patch round-trip loses data. Version not monotonic across mixed HTTP/WS updates. |+| **Settings slice** | `settings-slice.test.ts` | Stale WebSocket version overwrites newer data. Disconnect doesn't reset state. |+| **Calibration slice** | `calibration-slice.test.ts` | Partial config update nukes sibling fields. Thunk reducers leave wrong loading/error state. |+| **Mocap slice** | `mocap-slice.test.ts` | Detector/filter config merge drops fields. Default constants drifted from backend. |+| **Message guards** | `message-type-guards.test.ts` | `isSettingsStateMessage` lets malformed data through. Valid messages rejected so settings never update. |++## When to Run What++| You changed... | Run... |+|---|---|+| A Pydantic model field name or default | `uv run poe test-schema` |+| `SettingsManager` or `_deep_merge` | `uv run poe test-settings` |+| An HTTP endpoint or request/response model | `uv run poe test-http` then `uv run poe test-e2e` |+| WebSocket message handling | `uv run poe test-ws` then `uv run poe test-e2e` |+| Route mounting, prefixes, or middleware | `uv run poe test-e2e` |+| A Redux slice, thunk, or type guard | `cd freemocap-ui && npm test` |+| Anything in the settings sync path | `uv run poe test-sync` |+| About to push a commit | `uv run poe test-all` then `cd freemocap-ui && npm test` |\ No newline at end of filediff --git a/app-design-v2/src/components/layout/layout.types.ts b/app-design-v2/src/components/layout/layout.types.tsindex 9dea1e6c..36dc09e5 100644--- a/app-design-v2/src/components/layout/layout.types.ts+++ b/app-design-v2/src/components/layout/layout.types.ts@@ -1,4 +1,4 @@-// types/layout.types.ts+// types/layout.viewport3d-types.tsimport { type ReactElement, type MouseEvent } from "react";diff --git a/app-design-v2/src/store/slices/framerate/framerate-types.ts b/app-design-v2/src/store/slices/framerate/framerate-types.tsindex e14faaae..b3c60e3b 100644--- a/app-design-v2/src/store/slices/framerate/framerate-types.ts+++ b/app-design-v2/src/store/slices/framerate/framerate-types.ts@@ -1,4 +1,4 @@-// framerate-types.ts+// framerate-viewport3d-types.tsimport { z } from 'zod';// The actual framerate data structure used in the Redux storediff --git a/app-design-v2/src/store/slices/server/server-types.ts b/app-design-v2/src/store/slices/server/server-types.tsindex 65402eb7..8320fcce 100644--- a/app-design-v2/src/store/slices/server/server-types.ts+++ b/app-design-v2/src/store/slices/server/server-types.ts@@ -1,4 +1,4 @@-// store/slices/server/server-types.ts+// store/slices/server/server-viewport3d-types.ts/*** Server connection statusdiff --git a/freemocap-ui/electron/main/api.ts b/freemocap-ui/electron/main/api.tsindex ad01c274..d7d85f7f 100644--- a/freemocap-ui/electron/main/api.ts+++ b/freemocap-ui/electron/main/api.ts@@ -4,6 +4,9 @@ import superjson from 'superjson';// Servicesimport { PythonServer } from './services/python-server';+import { SystemScanner } from './services/system-scanner';+import { DependencyManager } from './services/dependency-manager';+import { AppSettings } from './services/app-settings';import { dialog, shell, app } from 'electron';import path from 'node:path';import fs from 'node:fs';@@ -11,7 +14,7 @@ import { APP_PATHS } from './app-paths';// Initialize tRPCconst t = initTRPC.create({- transformer: superjson, // Handles Date/undefined/etc serialization+ transformer: superjson,});// Helper function to check if a directory contains video files@@ -49,7 +52,6 @@ function findCameraCalibrationToml(dirPath: string): string | null {try {const entries = fs.readdirSync(dirPath);- // Look for files matching pattern: *_camera_calibration.tomlconst calibrationFile = entries.find(entry => {const fullPath = path.join(dirPath, entry);const stats = fs.statSync(fullPath);@@ -90,6 +92,54 @@ export const api = t.router({getProcessInfo: t.procedure.query(() => PythonServer.getProcessInfo()),++ getPort: t.procedure+ .query(() => PythonServer.getPort()),+ }),++ // System Scanner+ system: t.router({+ scan: t.procedure+ .query(() => SystemScanner.scan()),+ }),++ // Dependency Management+ dependencies: t.router({+ detectAll: t.procedure+ .query(() => DependencyManager.detectAll()),++ detect: t.procedure+ .input(z.object({ dependencyId: z.string() }))+ .query(({ input }) => DependencyManager.detect(input.dependencyId)),++ install: t.procedure+ .input(z.object({ dependencyId: z.string() }))+ .mutation(({ input }) => DependencyManager.install(input.dependencyId)),+ }),++ // Persistent Settings (file-backed at ~/.freemocap/settings.json)+ settings: t.router({+ get: t.procedure+ .input(z.object({ key: z.string() }))+ .query(({ input }) => AppSettings.get(input.key)),++ set: t.procedure+ .input(z.object({ key: z.string(), value: z.unknown() }))+ .mutation(({ input }) => {+ AppSettings.set(input.key, input.value);+ }),++ delete: t.procedure+ .input(z.object({ key: z.string() }))+ .mutation(({ input }) => {+ AppSettings.delete(input.key);+ }),++ getAll: t.procedure+ .query(() => AppSettings.getAll()),++ getConfigDir: t.procedure+ .query(() => AppSettings.getConfigDir()),}),// File System Operations@@ -160,17 +210,14 @@ export const api = t.router({};try {- // Check if directory existsresult.exists = fs.existsSync(input.directoryPath);if (!result.exists) {- // Directory doesn't exist - can record here (will be created)result.canRecord = true;result.canCalibrate = false;return result;}- // Directory exists - check its contentsconst stats = fs.statSync(input.directoryPath);if (!stats.isDirectory()) {@@ -178,30 +225,23 @@ export const api = t.router({return result;}- // Check for synchronized_videos folderconst synchronizedVideosPath = path.join(input.directoryPath, 'synchronized_videos');result.hasSynchronizedVideos = fs.existsSync(synchronizedVideosPath) &&fs.statSync(synchronizedVideosPath).isDirectory();- // Check for videos in synchronized_videos folderif (result.hasSynchronizedVideos) {result.hasVideos = hasVideoFiles(synchronizedVideosPath);}- // If no synchronized_videos, check for videos in root directoryif (!result.hasVideos) {result.hasVideos = hasVideoFiles(input.directoryPath);}- // Determine if we can record- // Can record if directory is empty or only has non-video filesconst entries = fs.readdirSync(input.directoryPath);result.canRecord = entries.length === 0 || !result.hasVideos;- // Can calibrate if we have videosresult.canCalibrate = result.hasVideos;- // Look for camera calibration TOML fileresult.cameraCalibrationTomlPath = findCameraCalibrationToml(input.directoryPath);return result;@@ -227,17 +267,14 @@ export const api = t.router({};try {- // Check if directory existsresult.exists = fs.existsSync(input.directoryPath);if (!result.exists) {- // Directory doesn't exist - can record here (will be created)result.canRecord = true;result.canProcess = false;return result;}- // Directory exists - check its contentsconst stats = fs.statSync(input.directoryPath);if (!stats.isDirectory()) {@@ -245,31 +282,23 @@ export const api = t.router({return result;}- // Check for synchronized_videos folderconst synchronizedVideosPath = path.join(input.directoryPath, 'synchronized_videos');result.hasSynchronizedVideos = fs.existsSync(synchronizedVideosPath) &&fs.statSync(synchronizedVideosPath).isDirectory();- // Check for videos in synchronized_videos folderif (result.hasSynchronizedVideos) {result.hasVideos = hasVideoFiles(synchronizedVideosPath);}- // If no synchronized_videos, check for videos in root directoryif (!result.hasVideos) {result.hasVideos = hasVideoFiles(input.directoryPath);}- // Determine if we can record- // Can record if directory is empty or only has non-video filesconst entries = fs.readdirSync(input.directoryPath);- result.canRecord = !result.hasVideos;- // Look for camera calibration TOML file+ result.canRecord = !result.hasVideos;result.cameraCalibrationTomlPath = findCameraCalibrationToml(input.directoryPath);- // Can process if we have videos and a calibration file- result.canProcess = result.hasVideos && result.cameraCalibrationTomlPath-+ result.canProcess = result.hasVideos && result.cameraCalibrationTomlPath !== null;return result;@@ -288,7 +317,6 @@ export const api = t.router({try {let logoPath: string | null = null;- // Check for logo in order of preferenceif (fs.existsSync(APP_PATHS.FREEMOCAP_LOGO_PNG_SHARED_PATH)) {logoPath = APP_PATHS.FREEMOCAP_LOGO_PNG_SHARED_PATH;} else if (fs.existsSync(APP_PATHS.FREEMOCAP_LOGO_PNG_RESOURCES_PATH)) {@@ -300,12 +328,10 @@ export const api = t.router({return null;}- // Read the file and convert to base64const imageBuffer = fs.readFileSync(logoPath);const base64String = imageBuffer.toString('base64');- const mimeType = 'image/png'; // Since we know it's a PNG+ const mimeType = 'image/png';- // Return as a data URL that can be used directly in img srcreturn `data:${mimeType};base64,${base64String}`;} catch (error) {console.error('Failed to load logo as base64:', error);@@ -313,7 +339,6 @@ export const api = t.router({}}),- // Keep the old method for backward compatibility if neededgetLogoPngPath: t.procedure.query(() => {if (fs.existsSync(APP_PATHS.FREEMOCAP_LOGO_PNG_SHARED_PATH)) {@@ -325,4 +350,4 @@ export const api = t.router({});// Export the type for use in renderer-export type AppAPI = typeof api;+export type AppAPI = typeof api;\ No newline at end of filediff --git a/freemocap-ui/electron/main/index.ts b/freemocap-ui/electron/main/index.tsindex 2ea0958b..e6224780 100644--- a/freemocap-ui/electron/main/index.ts+++ b/freemocap-ui/electron/main/index.ts@@ -1,31 +1,23 @@-// electron/main/index.tsimport { app, BrowserWindow } from 'electron';import { setupIPC } from './ipc';import { WindowManager } from './services/window-manager';import { PythonServer } from './services/python-server';-// import { UpdateHandler } from './services/update-handler';+import { buildAppMenu } from './services/app-menu';import { LifecycleLogger } from './services/logger';-// import os from 'node:os'; // Uncomment if needed for platform-specific checks-// Export environment configurationexport const APP_ENVIRONMENT = {IS_DEV: process.env.NODE_ENV === 'development',VITE_DEV_SERVER_URL: process.env.VITE_DEV_SERVER_URL,};--// Platform config-// if (os.release().startsWith('6.1')) app.disableHardwareAcceleration();if (process.platform === 'win32') app.setAppUserModelId(app.getName());-// Prevent multiple instancesconst gotTheLock = app.requestSingleInstanceLock();if (!gotTheLock) {app.quit();} else {app.on('second-instance', () => {- // Someone tried to run a second instance, focus our window insteadconst windows = BrowserWindow.getAllWindows();if (windows.length > 0) {const window = windows[0];@@ -34,23 +26,16 @@ if (!gotTheLock) {}});- // App lifecycleapp.whenReady().then(async () => {LifecycleLogger.logProcessInfo();console.log('App is ready');- // Setup IPCsetupIPC();- // Create windowconst mainWindow = WindowManager.createMainWindow();- //TODO: Re-enable auto-updates- // // Initialize auto-updater (only in production)- // if (!APP_ENVIRONMENT.IS_DEV) {- // UpdateHandler.initialize(mainWindow);- // }-+ // Set up the native application menu (File, Edit, View, Tools, etc.)+ buildAppMenu(mainWindow);});app.on('window-all-closed', async () => {diff --git a/freemocap-ui/electron/main/services/app-menu.ts b/freemocap-ui/electron/main/services/app-menu.tsnew file mode 100644index 00000000..15d215ab--- /dev/null+++ b/freemocap-ui/electron/main/services/app-menu.ts@@ -0,0 +1,144 @@+import { Menu, BrowserWindow, shell, app } from 'electron';+import path from 'node:path';+import os from 'node:os';++/**+ * Build and set the native application menu.+ * Call this once after the main window is created.+ */+export function buildAppMenu(mainWindow: BrowserWindow): void {+ const isMac = process.platform === 'darwin';++ const template: Electron.MenuItemConstructorOptions[] = [+ // macOS app menu+ ...(isMac ? [{+ label: app.name,+ submenu: [+ { role: 'about' as const },+ { type: 'separator' as const },+ {+ label: 'Settings…',+ click: () => sendNavigate(mainWindow, '/settings'),+ },+ { type: 'separator' as const },+ { role: 'services' as const },+ { type: 'separator' as const },+ { role: 'hide' as const },+ { role: 'hideOthers' as const },+ { role: 'unhide' as const },+ { type: 'separator' as const },+ { role: 'quit' as const },+ ],+ }] : []),++ // File+ {+ label: 'File',+ submenu: [+ isMac ? { role: 'close' as const } : { role: 'quit' as const },+ ],+ },++ // Edit+ {+ label: 'Edit',+ submenu: [+ { role: 'undo' as const },+ { role: 'redo' as const },+ { type: 'separator' as const },+ { role: 'cut' as const },+ { role: 'copy' as const },+ { role: 'paste' as const },+ { role: 'selectAll' as const },+ ],+ },++ // View+ {+ label: 'View',+ submenu: [+ { role: 'reload' as const },+ { role: 'forceReload' as const },+ { role: 'toggleDevTools' as const },+ { type: 'separator' as const },+ { role: 'resetZoom' as const },+ { role: 'zoomIn' as const },+ { role: 'zoomOut' as const },+ { type: 'separator' as const },+ { role: 'togglefullscreen' as const },+ ],+ },++ // Tools+ {+ label: 'Tools',+ submenu: [+ {+ label: 'Settings…',+ accelerator: isMac ? 'Cmd+Shift+S' : 'Ctrl+Shift+S',+ click: () => sendNavigate(mainWindow, '/settings'),+ },+ { type: 'separator' as const },+ {+ label: 'Open Config Folder',+ click: () => {+ const configDir = path.join(os.homedir(), '.freemocap');+ shell.openPath(configDir);+ },+ },+ {+ label: 'Open Data Folder',+ click: () => {+ const dataDir = path.join(os.homedir(), 'freemocap_data');+ shell.openPath(dataDir);+ },+ },+ ],+ },++ // Window+ {+ label: 'Window',+ submenu: [+ { role: 'minimize' as const },+ { role: 'zoom' as const },+ ...(isMac ? [+ { type: 'separator' as const },+ { role: 'front' as const },+ ] : [+ { role: 'close' as const },+ ]),+ ],+ },++ // Help+ {+ label: 'Help',+ submenu: [+ {+ label: 'FreeMoCap Documentation',+ click: () => shell.openExternal('https://freemocap.github.io/documentation/'),+ },+ {+ label: 'GitHub Repository',+ click: () => shell.openExternal('https://github.com/freemocap/freemocap'),+ },+ { type: 'separator' as const },+ {+ label: 'Settings…',+ click: () => sendNavigate(mainWindow, '/settings'),+ },+ ],+ },+ ];++ const menu = Menu.buildFromTemplate(template);+ Menu.setApplicationMenu(menu);+}++/** Send a navigation request to the renderer process. */+function sendNavigate(window: BrowserWindow, route: string): void {+ if (window.isDestroyed()) return;+ window.webContents.send('navigate', route);+ window.focus();+}\ No newline at end of filediff --git a/freemocap-ui/electron/main/services/app-settings.ts b/freemocap-ui/electron/main/services/app-settings.tsnew file mode 100644index 00000000..ac3ce52a--- /dev/null+++ b/freemocap-ui/electron/main/services/app-settings.ts@@ -0,0 +1,81 @@+import fs from 'node:fs';+import path from 'node:path';+import os from 'node:os';++const FREEMOCAP_CONFIG_DIR = path.join(os.homedir(), '.freemocap');+const SETTINGS_FILE = path.join(FREEMOCAP_CONFIG_DIR, 'settings.json');++type SettingsData = Record<string, unknown>;++function ensureConfigDir(): void {+ if (!fs.existsSync(FREEMOCAP_CONFIG_DIR)) {+ fs.mkdirSync(FREEMOCAP_CONFIG_DIR, { recursive: true });+ }+}++function readAll(): SettingsData {+ ensureConfigDir();+ if (!fs.existsSync(SETTINGS_FILE)) {+ return {};+ }+ const raw = fs.readFileSync(SETTINGS_FILE, 'utf-8');+ const parsed: unknown = JSON.parse(raw);+ if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {+ throw new Error(`Corrupted settings file: expected object, got ${typeof parsed}`);+ }+ return parsed as SettingsData;+}++function writeAll(data: SettingsData): void {+ ensureConfigDir();+ fs.writeFileSync(SETTINGS_FILE, JSON.stringify(data, null, 2), 'utf-8');+}++export class AppSettings {+ /** Get a single value by key. Returns null if the key doesn't exist. */+ static get(key: string): unknown {+ const data = readAll();+ if (!(key in data)) {+ return null;+ }+ return data[key];+ }++ /** Set a single key-value pair. */+ static set(key: string, value: unknown): void {+ const data = readAll();+ data[key] = value;+ writeAll(data);+ }++ /** Delete a single key. */+ static delete(key: string): void {+ const data = readAll();+ if (!(key in data)) {+ return;+ }+ delete data[key];+ writeAll(data);+ }++ /** Get all settings as a plain object. */+ static getAll(): SettingsData {+ return readAll();+ }++ /** Replace all settings with the given object. */+ static setAll(data: SettingsData): void {+ writeAll(data);+ }++ /** Get the path to the config directory (~/.freemocap/). */+ static getConfigDir(): string {+ ensureConfigDir();+ return FREEMOCAP_CONFIG_DIR;+ }++ /** Get the path to the settings file. */+ static getSettingsFilePath(): string {+ return SETTINGS_FILE;+ }+}diff --git a/freemocap-ui/electron/main/services/dependency-manager.ts b/freemocap-ui/electron/main/services/dependency-manager.tsnew file mode 100644index 00000000..c4aab5f1--- /dev/null+++ b/freemocap-ui/electron/main/services/dependency-manager.ts@@ -0,0 +1,372 @@+import { exec } from 'node:child_process';+import { promisify } from 'node:util';+import fs from 'node:fs';+import path from 'node:path';+import os from 'node:os';++const execAsync = promisify(exec);++// ── Types ──++export type DependencyStatus = 'installed' | 'missing' | 'outdated' | 'checking' | 'installing' | 'error';++export interface DependencyInfo {+ id: string;+ name: string;+ description: string;+ required: boolean;+ status: DependencyStatus;+ version: string | null;+ installedPath: string | null;+ error: string | null;+}++// ── Constants ──++const UV_INSTALL_URL_WINDOWS = 'https://astral.sh/uv/install.ps1';+const UV_INSTALL_URL_UNIX = 'https://astral.sh/uv/install.sh';++// ── Helpers ──++async function commandExists(command: string): Promise<{ exists: boolean; output: string }> {+ try {+ const { stdout } = await execAsync(+ process.platform === 'win32'+ ? `where ${command}`+ : `which ${command}`,+ { timeout: 10000 },+ );+ return { exists: true, output: stdout.trim() };+ } catch {+ return { exists: false, output: '' };+ }+}++async function getCommandVersion(command: string, versionFlag: string = '--version'): Promise<string | null> {+ try {+ const { stdout } = await execAsync(`${command} ${versionFlag}`, { timeout: 15000 });+ return stdout.trim().split('\n')[0];+ } catch {+ return null;+ }+}++// ── Blender Detection ──++async function detectBlender(): Promise<DependencyInfo> {+ const info: DependencyInfo = {+ id: 'blender',+ name: 'Blender',+ description: '3D creation suite — used for viewing and animating motion capture data.',+ required: false,+ status: 'checking',+ version: null,+ installedPath: null,+ error: null,+ };++ // Check PATH+ const { exists, output } = await commandExists('blender');+ if (exists) {+ info.installedPath = output.split('\n')[0].trim();+ info.version = await getCommandVersion('blender');+ info.status = 'installed';+ return info;+ }++ // Check common install locations+ const candidates: string[] = [];+ switch (process.platform) {+ case 'win32':+ // Common Windows paths+ const programFiles = process.env['ProgramFiles'] || 'C:\\Program Files';+ try {+ const blenderDir = path.join(programFiles, 'Blender Foundation');+ if (fs.existsSync(blenderDir)) {+ const versions = fs.readdirSync(blenderDir).sort().reverse();+ for (const ver of versions) {+ candidates.push(path.join(blenderDir, ver, 'blender.exe'));+ }+ }+ } catch { /* dir doesn't exist */ }+ break;+ case 'darwin':+ candidates.push('/Applications/Blender.app/Contents/MacOS/Blender');+ candidates.push('/Applications/Blender.app/Contents/MacOS/blender');+ break;+ case 'linux':+ candidates.push('/usr/bin/blender');+ candidates.push('/snap/bin/blender');+ candidates.push('/var/lib/flatpak/exports/bin/org.blender.Blender');+ break;+ }++ for (const candidate of candidates) {+ if (fs.existsSync(candidate)) {+ info.installedPath = candidate;+ try {+ const { stdout } = await execAsync(`"${candidate}" --version`, { timeout: 15000 });+ info.version = stdout.trim().split('\n')[0];+ } catch { /* version check failed but binary exists */ }+ info.status = 'installed';+ return info;+ }+ }++ info.status = 'missing';+ return info;+}++// ── uv Detection ──++async function detectUv(): Promise<DependencyInfo> {+ const info: DependencyInfo = {+ id: 'uv',+ name: 'uv',+ description: 'Fast Python package manager — useful for development and managing additional processing tools.',+ required: false,+ status: 'checking',+ version: null,+ installedPath: null,+ error: null,+ };++ const { exists, output } = await commandExists('uv');+ if (exists) {+ info.installedPath = output.split('\n')[0].trim();+ info.version = await getCommandVersion('uv');+ info.status = 'installed';+ return info;+ }++ // Check common uv install locations+ const home = os.homedir();+ const candidates: string[] = [];+ switch (process.platform) {+ case 'win32':+ candidates.push(path.join(home, '.local', 'bin', 'uv.exe'));+ candidates.push(path.join(home, '.cargo', 'bin', 'uv.exe'));+ break;+ case 'darwin':+ case 'linux':+ candidates.push(path.join(home, '.local', 'bin', 'uv'));+ candidates.push(path.join(home, '.cargo', 'bin', 'uv'));+ break;+ }++ for (const candidate of candidates) {+ if (fs.existsSync(candidate)) {+ info.installedPath = candidate;+ try {+ const { stdout } = await execAsync(`"${candidate}" --version`, { timeout: 10000 });+ info.version = stdout.trim();+ } catch { /* binary found but version check failed */ }+ info.status = 'installed';+ return info;+ }+ }++ info.status = 'missing';+ return info;+}++// ── FreeMoCap Server Executable Detection ──++async function detectFreemocapServer(): Promise<DependencyInfo> {+ const info: DependencyInfo = {+ id: 'freemocap-server',+ name: 'FreeMoCap Server',+ description: 'Bundled Python server that handles cameras, processing, and WebSocket communication.',+ required: true,+ status: 'checking',+ version: null,+ installedPath: null,+ error: null,+ };++ // Use the PythonServer candidate validation to find the exe+ try {+ const { PythonServer } = await import('./python-server');+ const candidates = await PythonServer.validateAllCandidates();+ const validCandidate = candidates.find(c => c.isValid);++ if (validCandidate) {+ info.status = 'installed';+ info.installedPath = validCandidate.path;+ info.version = validCandidate.name;+ } else {+ info.status = 'missing';+ info.error = 'No valid freemocap_server executable found. Reinstall the application or build the server.';+ }+ } catch (err) {+ info.status = 'error';+ info.error = `Detection failed: ${err instanceof Error ? err.message : String(err)}`;+ }++ return info;+}++// ── CUDA Detection ──++async function detectCuda(): Promise<DependencyInfo> {+ const info: DependencyInfo = {+ id: 'cuda',+ name: 'NVIDIA CUDA',+ description: 'GPU acceleration for pose estimation — dramatically speeds up processing.',+ required: false,+ status: 'checking',+ version: null,+ installedPath: null,+ error: null,+ };++ try {+ const { stdout } = await execAsync('nvidia-smi', { timeout: 10000 });+ // Parse CUDA version from nvidia-smi output+ const cudaMatch = stdout.match(/CUDA Version:\s*([\d.]+)/);+ if (cudaMatch) {+ info.version = `CUDA ${cudaMatch[1]}`;+ info.status = 'installed';+ } else {+ // nvidia-smi works but CUDA version not found — driver exists, CUDA toolkit may not+ const driverMatch = stdout.match(/Driver Version:\s*([\d.]+)/);+ info.version = driverMatch ? `Driver ${driverMatch[1]}` : 'Driver detected';+ info.status = 'installed';+ }+ } catch {+ info.status = 'missing';+ }++ return info;+}++// ── Installation ──++async function installBlender(): Promise<void> {+ switch (process.platform) {+ case 'win32': {+ // Try winget first+ const { exists: hasWinget } = await commandExists('winget');+ if (hasWinget) {+ const { stderr } = await execAsync(+ 'winget install BlenderFoundation.Blender --silent --accept-package-agreements --accept-source-agreements',+ { timeout: 600000 }, // 10 min timeout+ );+ if (stderr && stderr.includes('error')) {+ throw new Error(`winget install failed: ${stderr}`);+ }+ return;+ }+ throw new Error(+ 'winget is not available. Please install Blender manually from https://www.blender.org/download/',+ );+ }+ case 'darwin': {+ const { exists: hasBrew } = await commandExists('brew');+ if (hasBrew) {+ await execAsync('brew install --cask blender', { timeout: 600000 });+ return;+ }+ throw new Error(+ 'Homebrew is not available. Please install Blender manually from https://www.blender.org/download/',+ );+ }+ case 'linux': {+ // Try flatpak, then snap+ const { exists: hasFlatpak } = await commandExists('flatpak');+ if (hasFlatpak) {+ await execAsync(+ 'flatpak install -y flathub org.blender.Blender',+ { timeout: 600000 },+ );+ return;+ }+ const { exists: hasSnap } = await commandExists('snap');+ if (hasSnap) {+ await execAsync('sudo snap install blender --classic', { timeout: 600000 });+ return;+ }+ throw new Error(+ 'Neither flatpak nor snap is available. Please install Blender using your package manager.',+ );+ }+ default:+ throw new Error(`Unsupported platform: ${process.platform}`);+ }+}++async function installUv(): Promise<void> {+ switch (process.platform) {+ case 'win32':+ await execAsync(+ `powershell -ExecutionPolicy ByPass -c "irm ${UV_INSTALL_URL_WINDOWS} | iex"`,+ { timeout: 120000 },+ );+ break;+ case 'darwin':+ case 'linux':+ await execAsync(+ `curl -LsSf ${UV_INSTALL_URL_UNIX} | sh`,+ { timeout: 120000 },+ );+ break;+ default:+ throw new Error(`Unsupported platform: ${process.platform}`);+ }+}++// ── Public API ──++export class DependencyManager {+ static async detectAll(): Promise<DependencyInfo[]> {+ const results = await Promise.all([+ detectFreemocapServer(),+ detectUv(),+ detectCuda(),+ detectBlender(),+ ]);+ return results;+ }++ static async detect(dependencyId: string): Promise<DependencyInfo> {+ switch (dependencyId) {+ case 'freemocap-server':+ return detectFreemocapServer();+ case 'uv':+ return detectUv();+ case 'blender':+ return detectBlender();+ case 'cuda':+ return detectCuda();+ default:+ throw new Error(`Unknown dependency: ${dependencyId}`);+ }+ }++ static async install(dependencyId: string): Promise<DependencyInfo> {+ switch (dependencyId) {+ case 'blender':+ await installBlender();+ return detectBlender();++ case 'uv':+ await installUv();+ return detectUv();++ case 'freemocap-server':+ throw new Error(+ 'The FreeMoCap server executable is bundled with the application. ' ++ 'Reinstall the app to restore it.',+ );++ case 'cuda':+ throw new Error(+ 'CUDA cannot be installed automatically. ' ++ 'Please install the NVIDIA CUDA Toolkit from https://developer.nvidia.com/cuda-downloads',+ );++ default:+ throw new Error(`Unknown dependency: ${dependencyId}`);+ }+ }+}\ No newline at end of filediff --git a/freemocap-ui/electron/main/services/python-server.ts b/freemocap-ui/electron/main/services/python-server.tsindex c6b16365..941730c9 100644--- a/freemocap-ui/electron/main/services/python-server.ts+++ b/freemocap-ui/electron/main/services/python-server.ts@@ -9,20 +9,29 @@ import {PYTHON_EXECUTABLE_CANDIDATES} from "../app-paths";const treeKillAsync = promisify(treeKill);let pythonProcess: ReturnType<typeof exec> | null = null;+const PORT_SENTINEL = "FREEMOCAP_PORT";+const DEFAULT_PORT = 53117;+const PORT_DISCOVERY_TIMEOUT_MS = 30_000;+export interface ExecutableCandidate {name: string;path: string;description: string;isValid?: boolean;error?: string;- resolvedPath?: string; // Add resolved path for deduplication+ resolvedPath?: string;}export class PythonServer {private static currentExecutablePath: string | null = null;private static validatedCandidates: ExecutableCandidate[] = [];+ private static discoveredPort: number | null = null;- static async start(exePath: string | null = null) {+ /**+ * Start the Python server and wait for it to report which port it bound to.+ * Returns the actual port number.+ */+ static async start(exePath: string | null = null): Promise<number> {console.log('Starting python server subprocess...');try {@@ -31,17 +40,16 @@ export class PythonServer {let executablePath: string;if (exePath) {- // If specific path provided, validate itthis.validateExecutable(exePath);executablePath = exePath;console.log(`Using provided executable path: ${executablePath}`);} else {- // Find first valid executable from candidatesexecutablePath = await this.findValidExecutablePath();console.log(`Using auto-detected executable path: ${executablePath}`);}this.currentExecutablePath = executablePath;+ this.discoveredPort = null;console.log(`Launching Python server from: ${executablePath}`);pythonProcess = exec(`"${executablePath}"`, {env: {@@ -67,6 +75,12 @@ export class PythonServer {LifecycleLogger.logPythonProcess(pythonProcess);console.log(`✔ Python server started successfully (PID: ${pythonProcess.pid})`);+ const port = await this.waitForPort(pythonProcess);+ this.discoveredPort = port;+ console.log(`✔ Python server bound to port ${port}`);++ return port;+} catch (error) {console.error('Failed to start Python server:', error);this.currentExecutablePath = null;@@ -74,6 +88,54 @@ export class PythonServer {}}+ /**+ * Read stdout line-by-line until we find the port sentinel or time out.+ */+ private static waitForPort(proc: ReturnType<typeof exec>): Promise<number> {+ return new Promise((resolve, reject) => {+ const timeout = setTimeout(() => {+ reject(new Error(+ `Python server did not report a port within ${PORT_DISCOVERY_TIMEOUT_MS}ms`+ ));+ }, PORT_DISCOVERY_TIMEOUT_MS);++ const onData = (chunk: Buffer | string): void => {+ const text = chunk.toString();+ for (const line of text.split('\n')) {+ const trimmed = line.trim();+ if (trimmed.startsWith(`${PORT_SENTINEL}=`)) {+ const portStr = trimmed.slice(PORT_SENTINEL.length + 1);+ const port = parseInt(portStr, 10);+ if (isNaN(port)) {+ clearTimeout(timeout);+ reject(new Error(`Invalid port in sentinel line: ${trimmed}`));+ return;+ }+ clearTimeout(timeout);+ proc.stdout?.off('data', onData);+ resolve(port);+ return;+ }+ }+ };++ if (!proc.stdout) {+ clearTimeout(timeout);+ reject(new Error('Python process has no stdout stream'));+ return;+ }++ proc.stdout.on('data', onData);++ proc.on('exit', (code) => {+ clearTimeout(timeout);+ reject(new Error(+ `Python server exited with code ${code} before reporting a port`+ ));+ });+ });+ }+static async shutdown() {if (!pythonProcess || !pythonProcess.pid) {console.log('No Python server process to shutdown');@@ -83,12 +145,10 @@ export class PythonServer {console.log(`Shutting down Python server (PID: ${pythonProcess.pid})`);try {- // Kill entire process treeawait treeKillAsync(pythonProcess.pid);console.log('✔ Python server process tree terminated');} catch (error) {console.error('Error killing process tree:', error);- // Fallback to direct killtry {pythonProcess?.kill('SIGKILL');console.log('✔ Python server force-killed as fallback');@@ -97,7 +157,6 @@ export class PythonServer {}}- // Wait a moment for cleanupawait new Promise(resolve => setTimeout(resolve, 1000));if (pythonProcess && !pythonProcess.killed) {@@ -106,9 +165,17 @@ export class PythonServer {pythonProcess = null;this.currentExecutablePath = null;+ this.discoveredPort = null;console.log('✔ Python server shutdown complete');}+ /**+ * Get the port the Python server is currently bound to, or the default if not yet started.+ */+ static getPort(): number {+ return this.discoveredPort ?? DEFAULT_PORT;+ }+static getCurrentExecutablePath(): string | null {return this.currentExecutablePath;}@@ -116,12 +183,10 @@ export class PythonServer {static async findValidExecutablePath(): Promise<string> {console.log('Searching for valid Python server executable...');- // Validate all candidates if not done yetif (this.validatedCandidates.length === 0) {await this.validateAllCandidates();}- // Find first valid candidateconst validCandidate = this.validatedCandidates.find(candidate => candidate.isValid);if (!validCandidate) {@@ -137,7 +202,6 @@ export class PythonServer {static async validateAllCandidates(): Promise<ExecutableCandidate[]> {console.log('Validating all executable candidates...');- // First, validate all candidatesconst allValidatedCandidates = await Promise.all(PYTHON_EXECUTABLE_CANDIDATES.map(async (candidate) => {const validatedCandidate: ExecutableCandidate = {@@ -148,7 +212,6 @@ export class PythonServer {try {this.validateExecutable(candidate.path);validatedCandidate.isValid = true;- // Store resolved path for deduplicationvalidatedCandidate.resolvedPath = fs.existsSync(candidate.path)? path.resolve(candidate.path): candidate.path;@@ -162,18 +225,15 @@ export class PythonServer {}));- // Deduplicate by resolved pathconst seenPaths = new Set<string>();this.validatedCandidates = allValidatedCandidates.filter(candidate => {const pathKey = candidate.resolvedPath || candidate.path;- // If we've seen this path before, skip itif (seenPaths.has(pathKey)) {console.log(` ⚠ Skipping duplicate: ${candidate.name} (same as another candidate)`);return false;}- // Add to seen pathsseenPaths.add(pathKey);return true;});@@ -185,7 +245,7 @@ export class PythonServer {}static getPythonServerExecutableCandidates(): ExecutableCandidate[] {- return [...this.validatedCandidates]; // Return copy to prevent mutation+ return [...this.validatedCandidates];}static async refreshCandidates(): Promise<ExecutableCandidate[]> {@@ -208,23 +268,18 @@ export class PythonServer {}private static validateExecutable(exePath: string): void {- // Check if file existsif (!fs.existsSync(exePath)) {throw new Error(`Executable not found at: ${exePath}`);}- // Check if it's actually a file (not a directory)const stats = fs.statSync(exePath);if (!stats.isFile()) {throw new Error(`Path is not a file: ${exePath}`);}- // Check if file is executabletry {fs.accessSync(exePath, fs.constants.F_OK | fs.constants.R_OK);- // On Windows, we mainly check if file exists and is readable- // On Unix systems, we can check execute permissionsif (process.platform !== 'win32') {fs.accessSync(exePath, fs.constants.X_OK);}@@ -232,7 +287,6 @@ export class PythonServer {throw new Error(`File is not accessible or executable: ${exePath}`);}- // Additional validation: check file extension on Windowsif (process.platform === 'win32' && !exePath.toLowerCase().endsWith('.exe')) {console.warn(`Warning: Executable doesn't have .exe extension: ${exePath}`);}diff --git a/freemocap-ui/electron/main/services/system-scanner.ts b/freemocap-ui/electron/main/services/system-scanner.tsnew file mode 100644index 00000000..f2c4b163--- /dev/null+++ b/freemocap-ui/electron/main/services/system-scanner.ts@@ -0,0 +1,389 @@+import os from 'node:os';+import fs from 'node:fs';+import path from 'node:path';+import { execFile, exec } from 'node:child_process';+import { promisify } from 'node:util';+import { app } from 'electron';++const execFileAsync = promisify(execFile);+const execAsync = promisify(exec);++// ── Types ──++export interface CpuInfo {+ model: string;+ cores: number;+ threads: number;+ speedMhz: number;+}++export interface RamInfo {+ totalGb: number;+ availableGb: number;+}++export interface GpuInfo {+ name: string;+ vendor: string;+ vramMb: number | null;+ cudaAvailable: boolean;+ cudaVersion: string | null;+}++export interface DiskInfo {+ /** The drive/mount where freemocap data lives */+ path: string;+ totalGb: number;+ freeGb: number;+}++export interface OsInfo {+ platform: string;+ release: string;+ arch: string;+ hostname: string;+}++export type PerformanceTier = 'basic' | 'standard' | 'advanced' | 'pro';++export interface PerformanceRecommendation {+ tier: PerformanceTier;+ label: string;+ description: string;+ maxCameras: number;+ maxResolution: string;+ realtimeTracking: boolean;+ warnings: string[];+}++export interface SystemScanResult {+ cpu: CpuInfo;+ ram: RamInfo;+ gpus: GpuInfo[];+ disk: DiskInfo;+ os: OsInfo;+ recommendation: PerformanceRecommendation;+ scannedAt: string;+}++// ── Scanners ──++function scanCpu(): CpuInfo {+ const cpus = os.cpus();+ if (cpus.length === 0) {+ throw new Error('Failed to detect CPU info');+ }+ return {+ model: cpus[0].model.trim(),+ cores: new Set(cpus.map((_, i) => Math.floor(i / 2))).size || cpus.length,+ threads: cpus.length,+ speedMhz: cpus[0].speed,+ };+}++function scanRam(): RamInfo {+ const totalBytes = os.totalmem();+ const freeBytes = os.freemem();+ return {+ totalGb: Math.round((totalBytes / (1024 ** 3)) * 10) / 10,+ availableGb: Math.round((freeBytes / (1024 ** 3)) * 10) / 10,+ };+}++async function scanGpusWindows(): Promise<GpuInfo[]> {+ const gpus: GpuInfo[] = [];++ // Try WMIC first for all GPUs+ try {+ const { stdout } = await execAsync(+ 'wmic path win32_videocontroller get Name,AdapterRAM,DriverVersion /format:csv',+ { timeout: 10000 },+ );+ const lines = stdout.trim().split('\n').filter(l => l.trim().length > 0);+ // First line is header: Node,AdapterRAM,DriverVersion,Name+ for (let i = 1; i < lines.length; i++) {+ const parts = lines[i].split(',');+ if (parts.length < 4) continue;+ const adapterRam = parseInt(parts[1], 10);+ const name = parts[3]?.trim() || 'Unknown GPU';+ const isNvidia = name.toLowerCase().includes('nvidia');+ const isAmd = name.toLowerCase().includes('amd') || name.toLowerCase().includes('radeon');+ gpus.push({+ name,+ vendor: isNvidia ? 'NVIDIA' : isAmd ? 'AMD' : 'Other',+ vramMb: isNaN(adapterRam) ? null : Math.round(adapterRam / (1024 * 1024)),+ cudaAvailable: false, // Filled in below+ cudaVersion: null,+ });+ }+ } catch {+ // WMIC not available or failed+ }++ // Try nvidia-smi for CUDA info+ try {+ const { stdout } = await execAsync(+ 'nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv,noheader,nounits',+ { timeout: 10000 },+ );+ const lines = stdout.trim().split('\n');+ for (const line of lines) {+ const [name, vramMb, driverVersion] = line.split(',').map(s => s.trim());+ // Try to find matching GPU from WMIC and enrich it+ const existing = gpus.find(g => g.vendor === 'NVIDIA');+ if (existing) {+ existing.cudaAvailable = true;+ existing.cudaVersion = driverVersion || null;+ if (vramMb) {+ existing.vramMb = parseInt(vramMb, 10);+ }+ } else {+ gpus.push({+ name: name || 'NVIDIA GPU',+ vendor: 'NVIDIA',+ vramMb: vramMb ? parseInt(vramMb, 10) : null,+ cudaAvailable: true,+ cudaVersion: driverVersion || null,+ });+ }+ }+ } catch {+ // nvidia-smi not available — no CUDA+ }++ return gpus;+}++async function scanGpusMac(): Promise<GpuInfo[]> {+ const gpus: GpuInfo[] = [];+ try {+ const { stdout } = await execAsync(+ 'system_profiler SPDisplaysDataType',+ { timeout: 10000 },+ );+ // Parse the output for chipset/VRAM info+ const chipsetMatch = stdout.match(/Chipset Model:\s*(.+)/g);+ const vramMatch = stdout.match(/VRAM.*?:\s*(\d+)\s*(MB|GB)/gi);+ if (chipsetMatch) {+ for (let i = 0; i < chipsetMatch.length; i++) {+ const name = chipsetMatch[i].replace('Chipset Model:', '').trim();+ let vramMb: number | null = null;+ if (vramMatch && vramMatch[i]) {+ const m = vramMatch[i].match(/(\d+)\s*(MB|GB)/i);+ if (m) {+ vramMb = parseInt(m[1], 10);+ if (m[2].toUpperCase() === 'GB') vramMb *= 1024;+ }+ }+ const isApple = name.toLowerCase().includes('apple');+ gpus.push({+ name,+ vendor: isApple ? 'Apple' : 'Other',+ vramMb,+ cudaAvailable: false,+ cudaVersion: null,+ });+ }+ }+ } catch {+ // system_profiler failed+ }+ return gpus;+}++async function scanGpusLinux(): Promise<GpuInfo[]> {+ const gpus: GpuInfo[] = [];++ // lspci for GPU detection+ try {+ const { stdout } = await execAsync(+ 'lspci | grep -iE "vga|3d|display"',+ { timeout: 10000 },+ );+ for (const line of stdout.trim().split('\n')) {+ if (!line.trim()) continue;+ const name = line.replace(/^.*:\s*/, '').trim();+ const isNvidia = name.toLowerCase().includes('nvidia');+ const isAmd = name.toLowerCase().includes('amd') || name.toLowerCase().includes('radeon');+ gpus.push({+ name,+ vendor: isNvidia ? 'NVIDIA' : isAmd ? 'AMD' : 'Other',+ vramMb: null,+ cudaAvailable: false,+ cudaVersion: null,+ });+ }+ } catch {+ // lspci not available+ }++ // nvidia-smi for CUDA+ try {+ const { stdout } = await execAsync(+ 'nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv,noheader,nounits',+ { timeout: 10000 },+ );+ const lines = stdout.trim().split('\n');+ for (const line of lines) {+ const [name, vramMb, driverVersion] = line.split(',').map(s => s.trim());+ const existing = gpus.find(g => g.vendor === 'NVIDIA');+ if (existing) {+ existing.cudaAvailable = true;+ existing.cudaVersion = driverVersion || null;+ if (vramMb) existing.vramMb = parseInt(vramMb, 10);+ } else {+ gpus.push({+ name: name || 'NVIDIA GPU',+ vendor: 'NVIDIA',+ vramMb: vramMb ? parseInt(vramMb, 10) : null,+ cudaAvailable: true,+ cudaVersion: driverVersion || null,+ });+ }+ }+ } catch {+ // no nvidia-smi+ }++ return gpus;+}++async function scanGpus(): Promise<GpuInfo[]> {+ switch (process.platform) {+ case 'win32': return scanGpusWindows();+ case 'darwin': return scanGpusMac();+ case 'linux': return scanGpusLinux();+ default: return [];+ }+}++async function scanDisk(): Promise<DiskInfo> {+ const dataDir = path.join(app.getPath('home'), 'freemocap_data');+ // Use the drive/mount that the data directory lives on+ const targetPath = fs.existsSync(dataDir) ? dataDir : app.getPath('home');++ try {+ const stats = fs.statfsSync(targetPath);+ const blockSize = stats.bsize;+ const totalGb = Math.round((stats.blocks * blockSize) / (1024 ** 3) * 10) / 10;+ const freeGb = Math.round((stats.bavail * blockSize) / (1024 ** 3) * 10) / 10;+ return { path: targetPath, totalGb, freeGb };+ } catch {+ // statfsSync not available (very old Node) — return unknowns+ return { path: targetPath, totalGb: 0, freeGb: 0 };+ }+}++function scanOs(): OsInfo {+ return {+ platform: process.platform,+ release: os.release(),+ arch: os.arch(),+ hostname: os.hostname(),+ };+}++// ── Performance Recommendation ──++function computeRecommendation(+ cpu: CpuInfo,+ ram: RamInfo,+ gpus: GpuInfo[],+ disk: DiskInfo,+): PerformanceRecommendation {+ const warnings: string[] = [];+ const bestGpu = gpus.reduce<GpuInfo | null>((best, gpu) => {+ if (!best) return gpu;+ if (gpu.cudaAvailable && !best.cudaAvailable) return gpu;+ if ((gpu.vramMb ?? 0) > (best.vramMb ?? 0)) return gpu;+ return best;+ }, null);++ const hasCuda = bestGpu?.cudaAvailable ?? false;+ const vramMb = bestGpu?.vramMb ?? 0;++ // Disk warnings+ if (disk.freeGb > 0 && disk.freeGb < 20) {+ warnings.push(`Low disk space: ${disk.freeGb} GB free. Recordings can use 1-5 GB each.`);+ }++ // RAM warnings+ if (ram.totalGb < 8) {+ warnings.push('Less than 8 GB RAM — performance may be limited even with few cameras.');+ }++ // GPU warnings+ if (gpus.length === 0) {+ warnings.push('No dedicated GPU detected. Real-time pose tracking will not be available.');+ } else if (!hasCuda) {+ warnings.push('No NVIDIA GPU with CUDA detected. Mediapipe GPU acceleration will be unavailable.');+ }++ // Tier computation+ let tier: PerformanceTier;+ let label: string;+ let description: string;+ let maxCameras: number;+ let maxResolution: string;+ let realtimeTracking: boolean;++ if (cpu.threads >= 12 && ram.totalGb >= 32 && hasCuda && vramMb >= 8000) {+ tier = 'pro';+ label = 'Pro';+ description = 'Excellent system. Handles large multi-camera setups with real-time tracking and post-processing.';+ maxCameras = 8;+ maxResolution = '1080p';+ realtimeTracking = true;+ } else if (cpu.threads >= 8 && ram.totalGb >= 16 && hasCuda && vramMb >= 4000) {+ tier = 'advanced';+ label = 'Advanced';+ description = 'Strong system. Supports several cameras with real-time tracking.';+ maxCameras = 5;+ maxResolution = '1080p';+ realtimeTracking = true;+ } else if (cpu.threads >= 4 && ram.totalGb >= 12) {+ tier = 'standard';+ label = 'Standard';+ description = 'Good for multi-camera recording with offline processing.';+ maxCameras = 3;+ maxResolution = '720p';+ realtimeTracking = false;+ if (!hasCuda) {+ warnings.push('Pose estimation will run on CPU — processing will be slower but functional.');+ }+ } else {+ tier = 'basic';+ label = 'Basic';+ description = 'Can record from one or two cameras. Processing will be slow.';+ maxCameras = 2;+ maxResolution = '720p';+ realtimeTracking = false;+ }++ return { tier, label, description, maxCameras, maxResolution, realtimeTracking, warnings };+}++// ── Public API ──++export class SystemScanner {+ static async scan(): Promise<SystemScanResult> {+ const [cpu, ram, gpus, disk] = await Promise.all([+ scanCpu(),+ scanRam(),+ scanGpus(),+ scanDisk(),+ ]);+ const osInfo = scanOs();+ const recommendation = computeRecommendation(cpu, ram, gpus, disk);++ return {+ cpu,+ ram,+ gpus,+ disk,+ os: osInfo,+ recommendation,+ scannedAt: new Date().toISOString(),+ };+ }+}diff --git a/freemocap-ui/electron/main/services/window-manager.ts b/freemocap-ui/electron/main/services/window-manager.tsindex 70ce6ffd..1e2f219a 100644--- a/freemocap-ui/electron/main/services/window-manager.ts+++ b/freemocap-ui/electron/main/services/window-manager.ts@@ -1,20 +1,18 @@-// electron/main/services/window-manager.tsimport { BrowserWindow, shell } from 'electron';import { LifecycleLogger } from './logger';import { APP_ENVIRONMENT } from '../index';-import {APP_PATHS} from "../app-paths";+import { APP_PATHS } from '../app-paths';export class WindowManager {private static mainWindow: BrowserWindow | null = null;static createMainWindow(): BrowserWindow {- // Return existing window if already createdif (this.mainWindow && !this.mainWindow.isDestroyed()) {return this.mainWindow;}const window = new BrowserWindow({- title: 'Skellycam 💀📸',+ title: 'FreeMoCap 💀📸',icon: APP_PATHS.FREEMOCAP_ICON_PATH,width: 1280,height: 720,@@ -26,14 +24,13 @@ export class WindowManager {nodeIntegration: false,sandbox: true,},- show: false, // Don't show until ready+ show: false,});this.mainWindow = window;this.configureWindowHandlers(window);this.loadContent(window);- // Show window when readywindow.once('ready-to-show', () => {window.show();LifecycleLogger.logWindowCreation(window);@@ -55,21 +52,16 @@ export class WindowManager {window.webContents.send('app-ready', Date.now());});- // Handle external linkswindow.webContents.setWindowOpenHandler(({ url }) => {if (url.startsWith('http:') || url.startsWith('https:')) {shell.openExternal(url).catch(err =>- console.error('Failed to open external link:', err)+ console.error('Failed to open external link:', err),);}return { action: 'deny' };});- // Intercept navigation to external linkswindow.webContents.on('will-navigate', (event, url) => {- const currentURL = window.webContents.getURL();-- // Allow navigation within the appif (APP_ENVIRONMENT.IS_DEV && url.startsWith(APP_ENVIRONMENT.VITE_DEV_SERVER_URL!)) {return;}@@ -78,16 +70,14 @@ export class WindowManager {return;}- // Prevent navigation to external URLsif (url.startsWith('http:') || url.startsWith('https:')) {event.preventDefault();shell.openExternal(url).catch(err =>- console.error('Failed to open external link via navigation:', err)+ console.error('Failed to open external link via navigation:', err),);}});- // Handle crasheswindow.webContents.on('render-process-gone', (event, details) => {console.error('Renderer process gone:', details);if (details.reason === 'crashed') {@@ -101,7 +91,7 @@ export class WindowManager {if (APP_ENVIRONMENT.IS_DEV && APP_ENVIRONMENT.VITE_DEV_SERVER_URL) {window.loadURL(APP_ENVIRONMENT.VITE_DEV_SERVER_URL);- window.webContents.openDevTools();+ // window.webContents.openDevTools();} else {window.loadFile(APP_PATHS.RENDERER_HTML);}diff --git a/freemocap-ui/electron/preload/index.ts b/freemocap-ui/electron/preload/index.tsindex f088b918..2096156c 100644--- a/freemocap-ui/electron/preload/index.ts+++ b/freemocap-ui/electron/preload/index.ts@@ -1,8 +1,17 @@-import { contextBridge, ipcRenderer } from 'electron';-// Expose a simple tRPC bridgecontextBridge.exposeInMainWorld('electronAPI', {+ // tRPC bridgeinvoke: (path: string, input?: any) =>- ipcRenderer.invoke('trpc', { path, input })+ ipcRenderer.invoke('trpc', { path, input }),++ // Menu-triggered navigation: main process sends 'navigate' with a route string+ onNavigate: (callback: (route: string) => void) => {+ const handler = (_event: Electron.IpcRendererEvent, route: string) => callback(route);+ ipcRenderer.on('navigate', handler);+ // Return cleanup function+ return () => {+ ipcRenderer.removeListener('navigate', handler);+ };+ },});diff --git a/freemocap-ui/package.json b/freemocap-ui/package.jsonindex 8f543783..08652a87 100644--- a/freemocap-ui/package.json+++ b/freemocap-ui/package.json@@ -17,15 +17,22 @@"demo": "cross-env NODE_ENV=production vite build && electron .","build": "cross-env NODE_ENV=production && tsc && vite build && electron-builder","preview": "vite preview",+ "test": "vitest run",+ "test:watch": "vitest","pree2e": "vite build --mode=test","e2e": "playwright test"},"dependencies": {+ "@dnd-kit/core": "^6.3.1",+ "@dnd-kit/modifiers": "^9.0.0",+ "@dnd-kit/sortable": "^10.0.0",+ "@dnd-kit/utilities": "^3.2.2","@emotion/react": "^11.13.3","@emotion/styled": "^11.13.0","@ffmpeg/ffmpeg": "^0.12.10","@ffmpeg/util": "^0.12.1","@fontsource/roboto": "^5.1.0",+ "@monaco-editor/react": "^4.6.0","@msgpack/msgpack": "^3.0.0-beta2","@mui/icons-material": "^6.4.5","@mui/material": "^6.1.1",@@ -39,11 +46,13 @@"d3": "^7.9.0","electron-updater": "^6.1.8","exploration": "^1.6.0",+ "js-yaml": "^4.1.0","react-redux": "^9.1.2","react-resizable-panels": "^2.1.7","react-router": "^6.26.2","react-router-dom": "^6.26.2","react-use": "^17.5.1",+ "smol-toml": "^1.3.1","superjson": "^2.2.2","three": "^0.178.0","tree-kill": "^1.2.2",@@ -52,16 +61,17 @@"devDependencies": {"@playwright/test": "^1.42.1","@types/d3": "^7.4.3",+ "@types/js-yaml": "^4.0.9","@types/react": "^18.2.64","@types/react-dom": "^18.2.21","@vitejs/plugin-react": "^4.3.3","cross-env": "^7.0.3","electron": "^35.0.3","electron-builder": "^24.13.3",- "electron-devtools-installer": "^4.0.0","react": "^19.1.0","react-dom": "^19.1.0","vite": "^5.1.5",+ "vitest": "^3.2.1","vite-plugin-electron": "^0.28.8","vite-plugin-electron-renderer": "^0.14.5"}diff --git a/freemocap-ui/src/__tests__/calibration-slice.test.ts b/freemocap-ui/src/__tests__/calibration-slice.test.tsnew file mode 100644index 00000000..03141e76--- /dev/null+++ b/freemocap-ui/src/__tests__/calibration-slice.test.ts@@ -0,0 +1,287 @@+import { describe, it, expect } from 'vitest';+import {+ calibrationSlice,+ calibrationConfigUpdated,+ calibrationProgressUpdated,+ calibrationErrorCleared,+ manualCalibrationRecordingPathChanged,+ manualCalibrationRecordingPathCleared,+ calibrationDirectoryInfoUpdated,+ resetCalibrationState,+ CalibrationConfig,+ CalibrationState,+ CalibrationDirectoryInfo,+} from '@/store/slices/calibration/calibration-slice';++const reducer = calibrationSlice.reducer;++// ---------------------------------------------------------------------------+// Helpers+// ---------------------------------------------------------------------------++function getInitialState(): CalibrationState {+ return reducer(undefined, { type: 'unknown' });+}++// ---------------------------------------------------------------------------+// Initial state+// ---------------------------------------------------------------------------++describe('calibrationSlice initial state', () => {+ it('has correct default config values matching backend defaults', () => {+ const state = getInitialState();+ // These MUST match CalibrationPipelineConfig defaults on the backend+ expect(state.config.charucoBoardXSquares).toBe(5);+ expect(state.config.charucoBoardYSquares).toBe(3);+ expect(state.config.charucoSquareLength).toBe(1);+ expect(state.config.solverMethod).toBe('anipose');+ expect(state.config.useGroundplane).toBe(false);+ });++ it('starts not recording', () => {+ const state = getInitialState();+ expect(state.isRecording).toBe(false);+ expect(state.recordingProgress).toBe(0);+ });++ it('starts with no error', () => {+ const state = getInitialState();+ expect(state.error).toBeNull();+ });++ it('starts with no loading', () => {+ const state = getInitialState();+ expect(state.isLoading).toBe(false);+ });+});++// ---------------------------------------------------------------------------+// calibrationConfigUpdated+// ---------------------------------------------------------------------------++describe('calibrationConfigUpdated', () => {+ it('merges partial config update', () => {+ const state = getInitialState();+ const updated = reducer(state, calibrationConfigUpdated({+ charucoBoardXSquares: 7,+ }));+ expect(updated.config.charucoBoardXSquares).toBe(7);+ // Other fields should be preserved+ expect(updated.config.charucoBoardYSquares).toBe(3);+ expect(updated.config.charucoSquareLength).toBe(1);+ expect(updated.config.solverMethod).toBe('anipose');+ });++ it('can update solver method', () => {+ const state = getInitialState();+ const updated = reducer(state, calibrationConfigUpdated({+ solverMethod: 'pyceres',+ }));+ expect(updated.config.solverMethod).toBe('pyceres');+ });++ it('can update useGroundplane', () => {+ const state = getInitialState();+ const updated = reducer(state, calibrationConfigUpdated({+ useGroundplane: true,+ }));+ expect(updated.config.useGroundplane).toBe(true);+ });++ it('can update multiple fields at once', () => {+ const state = getInitialState();+ const updated = reducer(state, calibrationConfigUpdated({+ charucoBoardXSquares: 9,+ charucoBoardYSquares: 7,+ charucoSquareLength: 39.5,+ }));+ expect(updated.config.charucoBoardXSquares).toBe(9);+ expect(updated.config.charucoBoardYSquares).toBe(7);+ expect(updated.config.charucoSquareLength).toBe(39.5);+ });+});++// ---------------------------------------------------------------------------+// Progress and error+// ---------------------------------------------------------------------------++describe('calibrationProgressUpdated', () => {+ it('sets recording progress', () => {+ const state = getInitialState();+ const updated = reducer(state, calibrationProgressUpdated(42.5));+ expect(updated.recordingProgress).toBe(42.5);+ });+});++describe('calibrationErrorCleared', () => {+ it('clears error', () => {+ const state: CalibrationState = {+ ...getInitialState(),+ error: 'something went wrong',+ };+ const updated = reducer(state, calibrationErrorCleared());+ expect(updated.error).toBeNull();+ });+});++// ---------------------------------------------------------------------------+// Manual recording path+// ---------------------------------------------------------------------------++describe('manual recording path', () => {+ it('sets manual path', () => {+ const state = getInitialState();+ const updated = reducer(state, manualCalibrationRecordingPathChanged('/custom/path'));+ expect(updated.manualCalibrationRecordingPath).toBe('/custom/path');+ });++ it('clears manual path', () => {+ const state: CalibrationState = {+ ...getInitialState(),+ manualCalibrationRecordingPath: '/custom/path',+ };+ const updated = reducer(state, manualCalibrationRecordingPathCleared());+ expect(updated.manualCalibrationRecordingPath).toBeNull();+ });+});++// ---------------------------------------------------------------------------+// Directory info+// ---------------------------------------------------------------------------++describe('calibrationDirectoryInfoUpdated', () => {+ it('stores directory info', () => {+ const state = getInitialState();+ const info: CalibrationDirectoryInfo = {+ exists: true,+ canRecord: true,+ canCalibrate: true,+ cameraCalibrationTomlPath: '/tmp/cal/calibration.toml',+ hasSynchronizedVideos: true,+ hasVideos: true,+ errorMessage: null,+ };+ const updated = reducer(state, calibrationDirectoryInfoUpdated(info));+ expect(updated.directoryInfo).toEqual(info);+ });+});++// ---------------------------------------------------------------------------+// Reset+// ---------------------------------------------------------------------------++describe('resetCalibrationState', () => {+ it('resets everything to initial state', () => {+ const modified: CalibrationState = {+ config: {+ liveTrackCharuco: false,+ charucoBoardXSquares: 9,+ charucoBoardYSquares: 7,+ charucoSquareLength: 40,+ minSharedViewsPerCamera: 300,+ autoStopOnMinViewCount: false,+ solverMethod: 'pyceres',+ useGroundplane: true,+ },+ isRecording: true,+ recordingProgress: 50,+ isLoading: true,+ error: 'some error',+ lastCalibrationRecordingPath: '/some/path',+ manualCalibrationRecordingPath: '/manual/path',+ directoryInfo: null,+ };+ const reset = reducer(modified, resetCalibrationState());+ const fresh = getInitialState();+ expect(reset).toEqual(fresh);+ });+});++// ---------------------------------------------------------------------------+// Async thunk reducers (pending/fulfilled/rejected)+// ---------------------------------------------------------------------------++describe('startCalibrationRecording thunk reducers', () => {+ it('pending sets isLoading and clears error', () => {+ const state: CalibrationState = {+ ...getInitialState(),+ error: 'old error',+ };+ const updated = reducer(state, {+ type: 'calibration/startRecording/pending',+ });+ expect(updated.isLoading).toBe(true);+ expect(updated.error).toBeNull();+ });++ it('fulfilled sets isRecording and resets progress', () => {+ const state: CalibrationState = {+ ...getInitialState(),+ isLoading: true,+ };+ const updated = reducer(state, {+ type: 'calibration/startRecording/fulfilled',+ payload: { success: true },+ });+ expect(updated.isLoading).toBe(false);+ expect(updated.isRecording).toBe(true);+ expect(updated.recordingProgress).toBe(0);+ });++ it('fulfilled stores calibrationRecordingPath if provided', () => {+ const state: CalibrationState = {+ ...getInitialState(),+ isLoading: true,+ };+ const updated = reducer(state, {+ type: 'calibration/startRecording/fulfilled',+ payload: {+ success: true,+ calibrationRecordingPath: '/new/recording/path',+ },+ });+ expect(updated.lastCalibrationRecordingPath).toBe('/new/recording/path');+ });++ it('rejected sets error', () => {+ const state: CalibrationState = {+ ...getInitialState(),+ isLoading: true,+ };+ const updated = reducer(state, {+ type: 'calibration/startRecording/rejected',+ payload: 'Connection refused',+ });+ expect(updated.isLoading).toBe(false);+ expect(updated.error).toBe('Connection refused');+ });+});++describe('stopCalibrationRecording thunk reducers', () => {+ it('fulfilled stops recording', () => {+ const state: CalibrationState = {+ ...getInitialState(),+ isRecording: true,+ isLoading: true,+ recordingProgress: 80,+ };+ const updated = reducer(state, {+ type: 'calibration/stopRecording/fulfilled',+ payload: { success: true },+ });+ expect(updated.isLoading).toBe(false);+ expect(updated.isRecording).toBe(false);+ expect(updated.recordingProgress).toBe(0);+ });+});++describe('updateCalibrationConfigOnServer thunk reducers', () => {+ it('rejected sets error', () => {+ const state = getInitialState();+ const updated = reducer(state, {+ type: 'calibration/updateConfig/rejected',+ payload: 'Server error',+ });+ expect(updated.error).toBe('Server error');+ });+});diff --git a/freemocap-ui/src/__tests__/message-type-guards.test.ts b/freemocap-ui/src/__tests__/message-type-guards.test.tsnew file mode 100644index 00000000..2ce2c58e--- /dev/null+++ b/freemocap-ui/src/__tests__/message-type-guards.test.ts@@ -0,0 +1,197 @@+import { describe, it, expect } from 'vitest';+import {+ isSettingsStateMessage,+ isLogRecord,+ isFramerateUpdate,+} from '@/services/server/server-helpers/websocket-message-types';++// ---------------------------------------------------------------------------+// isSettingsStateMessage+// ---------------------------------------------------------------------------++describe('isSettingsStateMessage', () => {+ it('returns true for valid settings/state message', () => {+ const msg = {+ message_type: 'settings/state',+ settings: {+ cameras: {},+ pipeline: {},+ calibration: {},+ mocap: {},+ },+ version: 1,+ };+ expect(isSettingsStateMessage(msg)).toBe(true);+ });++ it('returns false if message_type is wrong', () => {+ const msg = {+ message_type: 'settings/patch',+ settings: {},+ version: 1,+ };+ expect(isSettingsStateMessage(msg)).toBe(false);+ });++ it('returns false if message_type is missing', () => {+ const msg = {+ settings: {},+ version: 1,+ };+ expect(isSettingsStateMessage(msg)).toBe(false);+ });++ it('returns false if settings is missing', () => {+ const msg = {+ message_type: 'settings/state',+ version: 1,+ };+ expect(isSettingsStateMessage(msg)).toBe(false);+ });++ it('returns false if settings is null', () => {+ const msg = {+ message_type: 'settings/state',+ settings: null,+ version: 1,+ };+ expect(isSettingsStateMessage(msg)).toBe(false);+ });++ it('returns false if version is missing', () => {+ const msg = {+ message_type: 'settings/state',+ settings: {},+ };+ expect(isSettingsStateMessage(msg)).toBe(false);+ });++ it('returns false if version is not a number', () => {+ const msg = {+ message_type: 'settings/state',+ settings: {},+ version: '1',+ };+ expect(isSettingsStateMessage(msg)).toBe(false);+ });++ it('returns false for null', () => {+ expect(isSettingsStateMessage(null)).toBe(false);+ });++ it('returns false for undefined', () => {+ expect(isSettingsStateMessage(undefined)).toBe(false);+ });++ it('returns false for a string', () => {+ expect(isSettingsStateMessage('hello')).toBe(false);+ });++ it('returns false for a number', () => {+ expect(isSettingsStateMessage(42)).toBe(false);+ });++ it('returns false for an empty object', () => {+ expect(isSettingsStateMessage({})).toBe(false);+ });+});++// ---------------------------------------------------------------------------+// isLogRecord+// ---------------------------------------------------------------------------++describe('isLogRecord', () => {+ it('returns true for valid log record', () => {+ const msg = {+ message_type: 'log_record',+ levelname: 'INFO',+ message: 'Something happened',+ levelno: 20,+ };+ expect(isLogRecord(msg)).toBe(true);+ });++ it('returns false if message_type is wrong', () => {+ const msg = {+ message_type: 'not_log',+ levelname: 'INFO',+ message: 'nope',+ };+ expect(isLogRecord(msg)).toBe(false);+ });++ it('returns false if levelname missing', () => {+ const msg = {+ message_type: 'log_record',+ message: 'no level',+ };+ expect(isLogRecord(msg)).toBe(false);+ });++ it('returns false if message missing', () => {+ const msg = {+ message_type: 'log_record',+ levelname: 'INFO',+ };+ expect(isLogRecord(msg)).toBe(false);+ });++ it('returns false for null', () => {+ expect(isLogRecord(null)).toBe(false);+ });+});++// ---------------------------------------------------------------------------+// isFramerateUpdate+// ---------------------------------------------------------------------------++describe('isFramerateUpdate', () => {+ it('returns true for valid framerate update', () => {+ const msg = {+ message_type: 'framerate_update',+ camera_group_id: 'group-0',+ backend_framerate: { fps: 30 },+ frontend_framerate: { fps: 28 },+ };+ expect(isFramerateUpdate(msg)).toBe(true);+ });++ it('returns false if message_type is wrong', () => {+ const msg = {+ message_type: 'not_framerate',+ camera_group_id: 'group-0',+ backend_framerate: {},+ frontend_framerate: {},+ };+ expect(isFramerateUpdate(msg)).toBe(false);+ });++ it('returns false if camera_group_id missing', () => {+ const msg = {+ message_type: 'framerate_update',+ backend_framerate: {},+ frontend_framerate: {},+ };+ expect(isFramerateUpdate(msg)).toBe(false);+ });++ it('returns false if backend_framerate is not an object', () => {+ const msg = {+ message_type: 'framerate_update',+ camera_group_id: 'group-0',+ backend_framerate: 30,+ frontend_framerate: {},+ };+ expect(isFramerateUpdate(msg)).toBe(false);+ });++ it('returns false if frontend_framerate is null', () => {+ const msg = {+ message_type: 'framerate_update',+ camera_group_id: 'group-0',+ backend_framerate: {},+ frontend_framerate: null,+ };+ expect(isFramerateUpdate(msg)).toBe(false);+ });+});diff --git a/freemocap-ui/src/__tests__/mocap-slice.test.ts b/freemocap-ui/src/__tests__/mocap-slice.test.tsnew file mode 100644index 00000000..6877e6bb--- /dev/null+++ b/freemocap-ui/src/__tests__/mocap-slice.test.ts@@ -0,0 +1,234 @@+import { describe, it, expect } from 'vitest';+import {+ mocapSlice,+ mocapDetectorConfigReplaced,+ mocapDetectorConfigUpdated,+ skeletonFilterConfigReplaced,+ skeletonFilterConfigUpdated,+ mocapErrorCleared,+ resetMocapState,+ MEDIAPIPE_REALTIME_PRESET,+ MEDIAPIPE_POSTHOC_PRESET,+ DEFAULT_ESTIMATOR_CONFIG,+ DEFAULT_REALTIME_FILTER_CONFIG,+ MocapState,+} from '@/store/slices/mocap/mocap-slice';++const reducer = mocapSlice.reducer;++function getInitialState(): MocapState {+ return reducer(undefined, { type: 'unknown' });+}++// ---------------------------------------------------------------------------+// Initial state — defaults must match backend+// ---------------------------------------------------------------------------++describe('mocapSlice initial state', () => {+ it('has detector config matching MEDIAPIPE_REALTIME_PRESET', () => {+ const state = getInitialState();+ expect(state.config.detector).toEqual(MEDIAPIPE_REALTIME_PRESET);+ });++ it('has skeleton_filter config matching DEFAULT_REALTIME_FILTER_CONFIG', () => {+ const state = getInitialState();+ expect(state.config.skeleton_filter).toEqual(DEFAULT_REALTIME_FILTER_CONFIG);+ });++ it('starts not recording', () => {+ const state = getInitialState();+ expect(state.isRecording).toBe(false);+ expect(state.recordingProgress).toBe(0);+ });++ it('starts with no error', () => {+ const state = getInitialState();+ expect(state.error).toBeNull();+ });+});++// ---------------------------------------------------------------------------+// Default constants match backend values+// ---------------------------------------------------------------------------++describe('default constants match backend', () => {+ describe('MEDIAPIPE_REALTIME_PRESET', () => {+ // These must match MEDIAPIPE_TRACKER_REALTIME_PRESET in skellytracker+ it('has model_complexity 0', () => {+ expect(MEDIAPIPE_REALTIME_PRESET.model_complexity).toBe(0);+ });+ it('has static_image_mode false', () => {+ expect(MEDIAPIPE_REALTIME_PRESET.static_image_mode).toBe(false);+ });+ it('has smooth_landmarks true', () => {+ expect(MEDIAPIPE_REALTIME_PRESET.smooth_landmarks).toBe(true);+ });+ });++ describe('DEFAULT_ESTIMATOR_CONFIG', () => {+ // Must match EstimatorConfig defaults in bone_length_estimator.py+ it('has max_samples 500', () => {+ expect(DEFAULT_ESTIMATOR_CONFIG.max_samples).toBe(500);+ });+ it('has min_samples_for_full_confidence 100', () => {+ expect(DEFAULT_ESTIMATOR_CONFIG.min_samples_for_full_confidence).toBe(100);+ });+ it('has iqr_confidence_sensitivity 10.0', () => {+ expect(DEFAULT_ESTIMATOR_CONFIG.iqr_confidence_sensitivity).toBe(10.0);+ });+ });++ describe('DEFAULT_REALTIME_FILTER_CONFIG', () => {+ // Must match RealtimeFilterConfig defaults in realtime_skeleton_filter.py+ it('has min_cutoff 0.005', () => {+ expect(DEFAULT_REALTIME_FILTER_CONFIG.min_cutoff).toBe(0.005);+ });+ it('has beta 0.3', () => {+ expect(DEFAULT_REALTIME_FILTER_CONFIG.beta).toBe(0.3);+ });+ it('has d_cutoff 1.0', () => {+ expect(DEFAULT_REALTIME_FILTER_CONFIG.d_cutoff).toBe(1.0);+ });+ it('has height_meters 1.75', () => {+ expect(DEFAULT_REALTIME_FILTER_CONFIG.height_meters).toBe(1.75);+ });+ it('has noise_sigma 0.015', () => {+ expect(DEFAULT_REALTIME_FILTER_CONFIG.noise_sigma).toBe(0.015);+ });+ it('has max_reprojection_error_px 60.0', () => {+ expect(DEFAULT_REALTIME_FILTER_CONFIG.max_reprojection_error_px).toBe(60.0);+ });+ it('has max_velocity_m_per_s 50.0', () => {+ expect(DEFAULT_REALTIME_FILTER_CONFIG.max_velocity_m_per_s).toBe(50.0);+ });+ it('has max_rejected_streak 5', () => {+ expect(DEFAULT_REALTIME_FILTER_CONFIG.max_rejected_streak).toBe(5);+ });+ it('has max_prediction_frames 15', () => {+ expect(DEFAULT_REALTIME_FILTER_CONFIG.max_prediction_frames).toBe(15);+ });+ it('has prediction_velocity_decay 0.75', () => {+ expect(DEFAULT_REALTIME_FILTER_CONFIG.prediction_velocity_decay).toBe(0.75);+ });+ });+});++// ---------------------------------------------------------------------------+// Detector config reducers+// ---------------------------------------------------------------------------++describe('mocapDetectorConfigReplaced', () => {+ it('replaces entire detector config', () => {+ const state = getInitialState();+ const updated = reducer(state, mocapDetectorConfigReplaced(MEDIAPIPE_POSTHOC_PRESET));+ expect(updated.config.detector).toEqual(MEDIAPIPE_POSTHOC_PRESET);+ expect(updated.config.detector.model_complexity).toBe(2);+ });+});++describe('mocapDetectorConfigUpdated', () => {+ it('merges partial update into detector config', () => {+ const state = getInitialState();+ const updated = reducer(state, mocapDetectorConfigUpdated({+ model_complexity: 1,+ }));+ expect(updated.config.detector.model_complexity).toBe(1);+ // Other fields preserved+ expect(updated.config.detector.smooth_landmarks).toBe(true);+ });+});++// ---------------------------------------------------------------------------+// Skeleton filter config reducers+// ---------------------------------------------------------------------------++describe('skeletonFilterConfigReplaced', () => {+ it('replaces entire filter config', () => {+ const state = getInitialState();+ const customFilter = {+ ...DEFAULT_REALTIME_FILTER_CONFIG,+ beta: 0.99,+ max_rejected_streak: 10,+ };+ const updated = reducer(state, skeletonFilterConfigReplaced(customFilter));+ expect(updated.config.skeleton_filter.beta).toBe(0.99);+ expect(updated.config.skeleton_filter.max_rejected_streak).toBe(10);+ });+});++describe('skeletonFilterConfigUpdated', () => {+ it('merges partial update into filter config', () => {+ const state = getInitialState();+ const updated = reducer(state, skeletonFilterConfigUpdated({ beta: 0.1 }));+ expect(updated.config.skeleton_filter.beta).toBe(0.1);+ // Other fields preserved from DEFAULT_REALTIME_FILTER_CONFIG+ expect(updated.config.skeleton_filter.min_cutoff).toBe(0.005);+ expect(updated.config.skeleton_filter.max_rejected_streak).toBe(5);+ });+});++// ---------------------------------------------------------------------------+// Error handling+// ---------------------------------------------------------------------------++describe('mocapErrorCleared', () => {+ it('clears error', () => {+ const state: MocapState = { ...getInitialState(), error: 'oops' };+ const updated = reducer(state, mocapErrorCleared());+ expect(updated.error).toBeNull();+ });+});++// ---------------------------------------------------------------------------+// Reset+// ---------------------------------------------------------------------------++describe('resetMocapState', () => {+ it('resets to initial state', () => {+ const modified: MocapState = {+ ...getInitialState(),+ config: {+ detector: MEDIAPIPE_POSTHOC_PRESET,+ skeleton_filter: { ...DEFAULT_REALTIME_FILTER_CONFIG, beta: 99 },+ },+ isRecording: true,+ error: 'err',+ };+ const reset = reducer(modified, resetMocapState());+ expect(reset).toEqual(getInitialState());+ });+});++// ---------------------------------------------------------------------------+// Async thunk reducers+// ---------------------------------------------------------------------------++describe('startMocapRecording thunk reducers', () => {+ it('pending sets isLoading', () => {+ const state = getInitialState();+ const updated = reducer(state, { type: 'mocap/startRecording/pending' });+ expect(updated.isLoading).toBe(true);+ expect(updated.error).toBeNull();+ });++ it('fulfilled sets isRecording', () => {+ const state: MocapState = { ...getInitialState(), isLoading: true };+ const updated = reducer(state, {+ type: 'mocap/startRecording/fulfilled',+ payload: { success: true },+ });+ expect(updated.isLoading).toBe(false);+ expect(updated.isRecording).toBe(true);+ expect(updated.recordingProgress).toBe(0);+ });++ it('rejected sets error', () => {+ const state: MocapState = { ...getInitialState(), isLoading: true };+ const updated = reducer(state, {+ type: 'mocap/startRecording/rejected',+ payload: 'Network error',+ });+ expect(updated.isLoading).toBe(false);+ expect(updated.error).toBe('Network error');+ });+});diff --git a/freemocap-ui/src/__tests__/settings-slice.test.ts b/freemocap-ui/src/__tests__/settings-slice.test.tsnew file mode 100644index 00000000..2d655a4c--- /dev/null+++ b/freemocap-ui/src/__tests__/settings-slice.test.ts@@ -0,0 +1,181 @@+import { describe, it, expect } from 'vitest';+import {+ settingsSlice,+ serverSettingsUpdated,+ serverSettingsCleared,+ ServerSettingsState,+} from '@/store/slices/settings/settings-slice';+import type {+ FreeMoCapSettings,+ SettingsStateMessage,+} from '@/store/slices/settings/settings-types';++const reducer = settingsSlice.reducer;++// ---------------------------------------------------------------------------+// Helpers+// ---------------------------------------------------------------------------++function makeSettings(overrides?: Partial<FreeMoCapSettings>): FreeMoCapSettings {+ return {+ cameras: {},+ pipeline: {+ config: null,+ is_connected: false,+ pipeline_id: null,+ camera_group_id: null,+ is_paused: false,+ },+ calibration: {+ config: {+ calibration_recording_folder: null,+ charuco_board_x_squares: 5,+ charuco_board_y_squares: 3,+ charuco_square_length: 1,+ solver_method: 'anipose',+ use_groundplane: false,+ pyceres_solver_config: {},+ },+ is_recording: false,+ recording_progress: 0,+ last_recording_path: null,+ has_calibration_toml: false,+ },+ mocap: {+ config: {+ detector: {},+ skeleton_filter: {+ min_cutoff: 0.005,+ beta: 0.3,+ d_cutoff: 1.0,+ fabrik_tolerance: 1e-4,+ fabrik_max_iterations: 20,+ height_meters: 1.75,+ noise_sigma: 0.015,+ estimator_config: {+ max_samples: 500,+ min_samples_for_full_confidence: 100,+ iqr_confidence_sensitivity: 10.0,+ },+ max_reprojection_error_px: 60.0,+ max_velocity_m_per_s: 50.0,+ max_rejected_streak: 5,+ max_prediction_frames: 15,+ prediction_velocity_decay: 0.75,+ },+ },+ is_recording: false,+ recording_progress: 0,+ last_recording_path: null,+ },+ vmc: {+ enabled: false,+ host: '127.0.0.1',+ port: 39539,+ },+ ...overrides,+ };+}++function makeStateMessage(+ version: number,+ settingsOverrides?: Partial<FreeMoCapSettings>,+): SettingsStateMessage {+ return {+ message_type: 'settings/state',+ settings: makeSettings(settingsOverrides),+ version,+ };+}++const initialState: ServerSettingsState = {+ settings: null,+ version: -1,+ lastUpdated: null,+ isInitialized: false,+};++// ---------------------------------------------------------------------------+// Tests+// ---------------------------------------------------------------------------++describe('settingsSlice', () => {+ it('has correct initial state', () => {+ const state = reducer(undefined, { type: 'unknown' });+ expect(state.settings).toBeNull();+ expect(state.version).toBe(-1);+ expect(state.lastUpdated).toBeNull();+ expect(state.isInitialized).toBe(false);+ });++ describe('serverSettingsUpdated', () => {+ it('applies a settings/state message with version > current', () => {+ const msg = makeStateMessage(1);+ const state = reducer(initialState, serverSettingsUpdated(msg));+ expect(state.settings).toEqual(msg.settings);+ expect(state.version).toBe(1);+ expect(state.isInitialized).toBe(true);+ expect(state.lastUpdated).not.toBeNull();+ });++ it('ignores a settings/state message with version <= current', () => {+ const firstMsg = makeStateMessage(5);+ const state1 = reducer(initialState, serverSettingsUpdated(firstMsg));++ const staleMsg = makeStateMessage(3, {+ calibration: {+ ...makeSettings().calibration,+ is_recording: true,+ },+ });+ const state2 = reducer(state1, serverSettingsUpdated(staleMsg));++ // Should not have changed+ expect(state2.version).toBe(5);+ expect(state2.settings!.calibration.is_recording).toBe(false);+ });++ it('ignores a settings/state message with same version', () => {+ const msg = makeStateMessage(5);+ const state1 = reducer(initialState, serverSettingsUpdated(msg));++ const sameVersionMsg = makeStateMessage(5, {+ calibration: {+ ...makeSettings().calibration,+ is_recording: true,+ },+ });+ const state2 = reducer(state1, serverSettingsUpdated(sameVersionMsg));+ expect(state2.settings!.calibration.is_recording).toBe(false);+ });++ it('applies newer version after an older one', () => {+ const msg1 = makeStateMessage(1);+ const state1 = reducer(initialState, serverSettingsUpdated(msg1));++ const msg2 = makeStateMessage(2, {+ calibration: {+ ...makeSettings().calibration,+ is_recording: true,+ },+ });+ const state2 = reducer(state1, serverSettingsUpdated(msg2));+ expect(state2.version).toBe(2);+ expect(state2.settings!.calibration.is_recording).toBe(true);+ });+ });++ describe('serverSettingsCleared', () => {+ it('resets to initial state', () => {+ const msg = makeStateMessage(5);+ const populated = reducer(initialState, serverSettingsUpdated(msg));+ expect(populated.isInitialized).toBe(true);++ const cleared = reducer(populated, serverSettingsCleared());+ expect(cleared.settings).toBeNull();+ expect(cleared.version).toBe(-1);+ expect(cleared.lastUpdated).toBeNull();+ expect(cleared.isInitialized).toBe(false);+ });+ });+});diff --git a/freemocap-ui/src/components/MenuNavigationListener.tsx b/freemocap-ui/src/components/MenuNavigationListener.tsxnew file mode 100644index 00000000..ac7e41ee--- /dev/null+++ b/freemocap-ui/src/components/MenuNavigationListener.tsx@@ -0,0 +1,26 @@+import React, { useEffect } from 'react';+import { useNavigate } from 'react-router-dom';++/**+ * Invisible component that listens for navigation events from the+ * native Electron menu (via the 'navigate' IPC channel) and forwards+ * them to react-router.+ *+ * Must be rendered inside a Router.+ */+export const MenuNavigationListener: React.FC = () => {+ const navigate = useNavigate();++ useEffect(() => {+ const electronAPI = (window as any).electronAPI;+ if (!electronAPI?.onNavigate) return;++ const cleanup = electronAPI.onNavigate((route: string) => {+ navigate(route);+ });++ return cleanup;+ }, [navigate]);++ return null;+};diff --git a/freemocap-ui/src/components/ServerConnectionStatus.tsx b/freemocap-ui/src/components/ServerConnectionStatus.tsxindex 944c1f61..2da18b11 100644--- a/freemocap-ui/src/components/ServerConnectionStatus.tsx+++ b/freemocap-ui/src/components/ServerConnectionStatus.tsx@@ -1,17 +1,17 @@-// components/ServerConnectionStatus.tsx-import React from 'react';-import {Box, IconButton, Typography} from "@mui/material";-import CheckIcon from '@mui/icons-material/Check';-import CloseIcon from '@mui/icons-material/Close';-import WifiIcon from '@mui/icons-material/Wifi';-import WifiOffIcon from '@mui/icons-material/WifiOff';-+import React from "react";+import {Box, Chip, Tooltip, useTheme} from "@mui/material";+import WifiIcon from "@mui/icons-material/Wifi";+import WifiOffIcon from "@mui/icons-material/WifiOff";+import CheckIcon from "@mui/icons-material/Check";+import {CollapsibleSidebarSection} from "@/components/common/CollapsibleSidebarSection";import {useServer} from "@/hooks/useServer";export const ServerConnectionStatus: React.FC = () => {- const { isConnected, connect, disconnect, connectedCameraIds } = useServer();+ const theme = useTheme();+ const {isConnected, connect, disconnect, connectedCameraIds} = useServer();- const handleClick = (): void => {+ const handleToggle = (e: React.MouseEvent): void => {+ e.stopPropagation();if (isConnected) {disconnect();} else {@@ -19,86 +19,94 @@ export const ServerConnectionStatus: React.FC = () => {}};- const getStatusColor = (): { bg: string; border: string; text: string } => {- if (isConnected) {- return {- bg: 'rgba(0, 255, 255, 0.05)',- border: 'rgba(0, 255, 255, 0.3)',- text: '#00ffff'- };+ // Original cyan/red color mapping+ const colors = isConnected+ ? {+ bg: "rgba(0, 255, 255, 0.1)",+ border: "rgba(0, 255, 255, 0.5)",+ text: "#00ffff",+ hoverBg: "rgba(0, 255, 255, 0.2)",}- return {- bg: 'rgba(255, 0, 0, 0.1)',- border: 'rgba(255, 0, 0, 0.3)',- text: '#f44336'+ : {+ bg: "rgba(255, 0, 0, 0.1)",+ border: "rgba(255, 0, 0, 0.5)",+ text: "#f44336",+ hoverBg: "rgba(255, 0, 0, 0.2)",};- };-- const colors = getStatusColor();return (- <Box- onClick={handleClick}- sx={{- display: 'flex',- alignItems: 'center',- gap: 1,- padding: '8px 12px',- cursor: 'pointer',- border: `1px solid ${colors.border}`,- borderRadius: '8px',- backgroundColor: colors.bg,- transition: 'all 0.2s ease',- ':hover': {- opacity: 0.8,- transform: 'translateY(-1px)',- boxShadow: '0 2px 8px rgba(0, 0, 0, 0.1)',- },- }}+ <CollapsibleSidebarSection+ icon={+ isConnected ? (+ <WifiIcon sx={{color: "inherit"}} />+ ) : (+ <WifiOffIcon sx={{color: "inherit"}} />+ )+ }+ title="WebSocket"+ summaryContent={+ isConnected && connectedCameraIds.length > 0 ? (+ <Chip+ label={`${connectedCameraIds.length} cam${connectedCameraIds.length !== 1 ? "s" : ""}`}+ size="small"+ variant="outlined"+ sx={{+ height: 18,+ fontSize: 10,+ borderColor: "rgba(255,255,255,0.4)",+ color: "inherit",+ }}+ />+ ) : null+ }+ primaryControl={+ <Tooltip title={isConnected ? "Click to disconnect" : "Click to connect"}>+ <Box+ onClick={handleToggle}+ sx={{+ display: "flex",+ alignItems: "center",+ gap: 0.75,+ cursor: "pointer",+ borderRadius: 1,+ border: `2px solid ${colors.border}`,+ backgroundColor: colors.bg,+ px: 2,+ py: 0.5,+ transition: "all 0.2s ease",+ "&:hover": {+ backgroundColor: colors.hoverBg,+ transform: "translateY(-1px)",+ boxShadow: `0 2px 8px ${colors.border}`,+ },+ }}+ >+ {isConnected ? (+ <CheckIcon sx={{fontSize: 18, color: colors.text}} />+ ) : null}+ <Box+ component="span"+ sx={{+ fontSize: 14,+ fontWeight: 700,+ lineHeight: 1,+ color: colors.text,+ whiteSpace: "nowrap",+ }}+ >+ {isConnected ? "Connected" : "Connect"}+ </Box>+ </Box>+ </Tooltip>+ }+ defaultExpanded={false}>- <IconButton- size="small"- sx={{- p: 0.5,- color: colors.text,- backgroundColor: 'rgba(255, 255, 255, 0.1)',- ':hover': { backgroundColor: 'rgba(255, 255, 255, 0.2)' }- }}- >- {isConnected ? <WifiIcon /> : <WifiOffIcon />}- </IconButton>-- <Box>- <Typography- variant="body2"- sx={{- fontWeight: 500,- color: colors.text,- display: 'flex',- alignItems: 'center',- gap: 0.5- }}- >- WebSocket: {isConnected ? 'Connected' : 'Disconnected'}- {isConnected ? (- <CheckIcon sx={{ fontSize: 16 }} />- ) : (- <CloseIcon sx={{ fontSize: 16 }} />- )}- </Typography>-- {isConnected && connectedCameraIds.length > 0 && (- <Typography variant="caption" sx={{ color: 'text.secondary' }}>- {connectedCameraIds.length} camera{connectedCameraIds.length !== 1 ? 's' : ''} active- </Typography>- )}-- {!isConnected && (- <Typography variant="caption" sx={{ color: 'text.secondary' }}>- Click to connect- </Typography>- )}+ {/* Future: server address, port, reconnect behavior settings */}+ <Box sx={{p: 2, color: theme.palette.text.secondary, fontSize: 14}}>+ {isConnected+ ? "WebSocket connection active. Click the button to disconnect."+ : "No active connection. Click the button to connect."}</Box>- </Box>+ </CollapsibleSidebarSection>);};diff --git a/freemocap-ui/src/components/calibration-control-panel/CalibrationControlPanel.tsx b/freemocap-ui/src/components/calibration-control-panel/CalibrationControlPanel.tsxnew file mode 100644index 00000000..dc296868--- /dev/null+++ b/freemocap-ui/src/components/calibration-control-panel/CalibrationControlPanel.tsx@@ -0,0 +1,624 @@+import React, {useCallback, useEffect, useMemo, useState} from "react";+import {+ Alert,+ Box,+ Button,+ Checkbox,+ Chip,+ FormControl,+ FormControlLabel,+ IconButton,+ InputAdornment,+ InputLabel,+ MenuItem,+ Select,+ Stack,+ TextField,+ Tooltip,+ Typography,+ useTheme,+} from "@mui/material";+import SquareFootIcon from "@mui/icons-material/SquareFoot";+import PlayArrowIcon from "@mui/icons-material/PlayArrow";+import StopIcon from "@mui/icons-material/Stop";+import FolderOpenIcon from "@mui/icons-material/FolderOpen";+import ClearIcon from "@mui/icons-material/Clear";+import CheckCircleIcon from "@mui/icons-material/CheckCircle";+import InfoIcon from "@mui/icons-material/Info";+import CloseIcon from "@mui/icons-material/Close";+import FiberManualRecordIcon from "@mui/icons-material/FiberManualRecord";+import {CollapsibleSidebarSection} from "@/components/common/CollapsibleSidebarSection";+import {useCalibration} from "@/hooks/useCalibration";+import {useElectronIPC} from "@/services";+import {CalibrationSolverSection} from "@/components/calibration-control-panel/CalibrationSolverSection";++type BoardPreset = "5x3" | "7x5" | "custom";++interface BoardPresetConfig {+ xSquares: number;+ ySquares: number;+}++const BOARD_PRESETS: Record<Exclude<BoardPreset, "custom">, BoardPresetConfig> = {+ "5x3": {xSquares: 5, ySquares: 3},+ "7x5": {xSquares: 7, ySquares: 5},+};++export const CalibrationControlPanel: React.FC = () => {+ const theme = useTheme();+ const [localError, setLocalError] = useState<string | null>(null);+ const {api} = useElectronIPC();++ const {+ config,+ error,+ isLoading,+ isRecording,+ recordingProgress,+ canStartRecording,+ canCalibrate,+ calibrationRecordingPath,+ directoryInfo,+ isUsingManualPath,+ updateCalibrationConfig,+ dispatchStopCalibrationRecording,+ dispatchStartCalibrationRecording,+ setManualRecordingPath,+ clearManualRecordingPath,+ validateDirectory,+ calibrateSelectedRecording,+ clearError,+ } = useCalibration();++ useEffect(() => {+ if (calibrationRecordingPath) {+ validateDirectory(calibrationRecordingPath);+ }+ }, [calibrationRecordingPath, validateDirectory]);++ const currentPreset = useMemo<BoardPreset>(() => {+ for (const [preset, presetConfig] of Object.entries(BOARD_PRESETS)) {+ if (+ presetConfig.xSquares === config.charucoBoardXSquares &&+ presetConfig.ySquares === config.charucoBoardYSquares+ ) {+ return preset as BoardPreset;+ }+ }+ return "custom";+ }, [config.charucoBoardXSquares, config.charucoBoardYSquares]);++ const handleClearError = useCallback((): void => {+ clearError();+ setLocalError(null);+ }, [clearError]);++ const handlePresetChange = useCallback(+ (preset: BoardPreset): void => {+ if (preset === "custom") return;+ const presetConfig = BOARD_PRESETS[preset];+ updateCalibrationConfig({+ charucoBoardXSquares: presetConfig.xSquares,+ charucoBoardYSquares: presetConfig.ySquares,+ });+ },+ [updateCalibrationConfig]+ );++ const handleXSquaresChange = useCallback(+ (value: string): void => {+ const numValue = parseInt(value, 10);+ if (!isNaN(numValue) && numValue > 0) {+ updateCalibrationConfig({charucoBoardXSquares: numValue});+ }+ },+ [updateCalibrationConfig]+ );++ const handleYSquaresChange = useCallback(+ (value: string): void => {+ const numValue = parseInt(value, 10);+ if (!isNaN(numValue) && numValue > 0) {+ updateCalibrationConfig({charucoBoardYSquares: numValue});+ }+ },+ [updateCalibrationConfig]+ );++ const handleSelectDirectory = async (): Promise<void> => {+ if (!api) {+ console.warn("Electron API not available");+ return;+ }+ try {+ const result: string | null = await api.fileSystem.selectDirectory.mutate();+ if (result) {+ await setManualRecordingPath(result);+ }+ } catch (err) {+ console.error("Failed to select directory:", err);+ setLocalError("Failed to select directory");+ }+ };++ const handlePathInputChange = async (+ e: React.ChangeEvent<HTMLInputElement>+ ): Promise<void> => {+ const newPath: string = e.target.value;+ if (newPath.includes("~") && api) {+ try {+ const home: string = await api.fileSystem.getHomeDirectory.query();+ const expanded: string = newPath.replace(+ /^~([/\\])?/,+ home ? `${home}$1` : ""+ );+ await setManualRecordingPath(expanded);+ } catch (err) {+ console.error("Failed to expand home directory:", err);+ await setManualRecordingPath(newPath);+ }+ } else {+ await setManualRecordingPath(newPath);+ }+ };++ const handleClearManualPath = useCallback((): void => {+ clearManualRecordingPath();+ }, [clearManualRecordingPath]);++ const displayError = error || localError || directoryInfo?.errorMessage;++ const pathHelperText = useMemo(() => {+ if (isUsingManualPath) return "Using custom path";+ return "Using default recording directory";+ }, [isUsingManualPath]);++ // Derive status for collapsed summary+ const statusLabel = isRecording+ ? `Recording ${recordingProgress.toFixed(0)}%`+ : isLoading+ ? "Processing..."+ : directoryInfo?.cameraCalibrationTomlPath+ ? "Calibrated"+ : "Idle";++ const statusColor = isRecording+ ? theme.palette.error.main+ : isLoading+ ? theme.palette.warning.main+ : directoryInfo?.cameraCalibrationTomlPath+ ? theme.palette.success.main+ : theme.palette.grey[600];++ // Primary control: compact start/stop recording toggle in the header+ const headerRecordButton = isRecording ? (+ <Tooltip title="Stop calibration recording">+ <IconButton+ size="small"+ onClick={(e: React.MouseEvent) => {+ e.stopPropagation();+ dispatchStopCalibrationRecording();+ }}+ disabled={isLoading}+ sx={{+ color: theme.palette.error.light,+ border: `1.5px solid ${theme.palette.error.light}`,+ borderRadius: 1,+ p: 0.5,+ "&:hover": {backgroundColor: "rgba(244,67,54,0.15)"},+ }}+ >+ <StopIcon fontSize="small" />+ </IconButton>+ </Tooltip>+ ) : (+ <Tooltip title={canStartRecording ? "Start calibration recording" : "Cannot record yet"}>+ <span>+ <IconButton+ size="small"+ onClick={(e: React.MouseEvent) => {+ e.stopPropagation();+ dispatchStartCalibrationRecording();+ }}+ disabled={!canStartRecording || isLoading}+ sx={{+ color: "inherit",+ border: "1.5px solid rgba(255,255,255,0.25)",+ borderRadius: 1,+ p: 0.5,+ "&:hover": {backgroundColor: "rgba(255,255,255,0.1)"},+ "&.Mui-disabled": {+ color: "rgba(255,255,255,0.3)",+ borderColor: "rgba(255,255,255,0.1)",+ },+ }}+ >+ <FiberManualRecordIcon fontSize="small" />+ </IconButton>+ </span>+ </Tooltip>+ );++ return (+ <CollapsibleSidebarSection+ icon={<SquareFootIcon sx={{color: "inherit"}} />}+ title="Calibration"+ summaryContent={+ <Chip+ label={statusLabel}+ size="small"+ sx={{+ height: 20,+ fontSize: 11,+ fontWeight: 600,+ backgroundColor: statusColor,+ color: theme.palette.getContrastText(statusColor),+ }}+ />+ }+ primaryControl={headerRecordButton}+ defaultExpanded={false}+ >+ <Box sx={{p: 2, bgcolor: "background.paper"}}>+ <Stack spacing={2}>+ {/* Error Display */}+ {displayError && (+ <Alert severity="error" onClose={handleClearError}>+ {displayError}+ </Alert>+ )}++ {/* Live Tracker Toggle */}+ <FormControlLabel+ control={+ <Checkbox+ checked={config.liveTrackCharuco}+ onChange={(e) =>+ updateCalibrationConfig({+ liveTrackCharuco: e.target.checked,+ })+ }+ disabled={isLoading}+ sx={{+ "&.Mui-checked": {+ color: theme.palette.text.primary,+ },+ }}+ />+ }+ label="Live Track Charuco Board"+ />++ {/* Recording Controls */}+ <Stack direction="row" spacing={2}>+ <Button+ variant="contained"+ color="primary"+ startIcon={<PlayArrowIcon />}+ onClick={dispatchStartCalibrationRecording}+ disabled={!canStartRecording || isLoading}+ fullWidth+ >+ Start Calibration Recording+ </Button>+ {isRecording && (+ <Button+ variant="contained"+ color="error"+ startIcon={<StopIcon />}+ onClick={dispatchStopCalibrationRecording}+ disabled={isLoading}+ fullWidth+ >+ Stop Recording+ </Button>+ )}+ </Stack>++ {/* Recording Path Input */}+ <TextField+ label="Calibration Recording Path"+ value={calibrationRecordingPath}+ onChange={handlePathInputChange}+ fullWidth+ size="small"+ helperText={pathHelperText}+ InputProps={{+ endAdornment: (+ <InputAdornment position="end">+ {isUsingManualPath && (+ <Tooltip title="Clear manual path (revert to default)">+ <IconButton+ onClick={handleClearManualPath}+ edge="end"+ size="small"+ >+ <ClearIcon fontSize="small" />+ </IconButton>+ </Tooltip>+ )}+ <Tooltip title="Select directory">+ <IconButton+ onClick={handleSelectDirectory}+ edge="end"+ >+ <FolderOpenIcon />+ </IconButton>+ </Tooltip>+ </InputAdornment>+ ),+ }}+ />++ {/* Directory Status Info */}+ {directoryInfo && (+ <Box+ sx={{+ p: 1.5,+ borderRadius: 1,+ border: `2px solid ${theme.palette.divider}`,+ }}+ >+ <Stack spacing={1}>+ <Box+ sx={{+ display: "flex",+ alignItems: "center",+ gap: 1,+ }}+ >+ <InfoIcon fontSize="small" color="info" />+ <Typography variant="caption" fontWeight="medium">+ Calibration Folder Status+ </Typography>+ </Box>++ <Box+ sx={{+ display: "flex",+ gap: 1,+ flexWrap: "wrap",+ }}+ >+ <Chip+ label={+ directoryInfo.exists+ ? "Directory exists"+ : "Directory will be created"+ }+ size="small"+ color={directoryInfo.exists ? "success" : "default"}+ icon={+ directoryInfo.exists ? (+ <CheckCircleIcon />+ ) : (+ <CloseIcon />+ )+ }+ variant={directoryInfo.exists ? "filled" : "outlined"}+ sx={+ !directoryInfo.exists+ ? {+ borderColor: theme.palette.grey[400],+ "& .MuiChip-icon": {+ color: theme.palette.grey[600],+ },+ }+ : {}+ }+ />+ <Chip+ label="Has videos"+ size="small"+ color={directoryInfo.hasVideos ? "success" : "default"}+ icon={+ directoryInfo.hasVideos ? (+ <CheckCircleIcon />+ ) : (+ <CloseIcon />+ )+ }+ variant={directoryInfo.hasVideos ? "filled" : "outlined"}+ sx={+ !directoryInfo.hasVideos+ ? {+ borderColor: theme.palette.grey[400],+ "& .MuiChip-icon": {+ color: theme.palette.grey[600],+ },+ }+ : {}+ }+ />+ <Chip+ label="Has synchronized_videos"+ size="small"+ color={+ directoryInfo.hasSynchronizedVideos+ ? "success"+ : "default"+ }+ icon={+ directoryInfo.hasSynchronizedVideos ? (+ <CheckCircleIcon />+ ) : (+ <CloseIcon />+ )+ }+ variant={+ directoryInfo.hasSynchronizedVideos+ ? "filled"+ : "outlined"+ }+ sx={+ !directoryInfo.hasSynchronizedVideos+ ? {+ borderColor: theme.palette.grey[400],+ "& .MuiChip-icon": {+ color: theme.palette.grey[600],+ },+ }+ : {}+ }+ />+ <Chip+ label="Has calibration TOML"+ size="small"+ color={+ directoryInfo.cameraCalibrationTomlPath+ ? "success"+ : "default"+ }+ icon={+ directoryInfo.cameraCalibrationTomlPath ? (+ <CheckCircleIcon />+ ) : (+ <CloseIcon />+ )+ }+ variant={+ directoryInfo.cameraCalibrationTomlPath+ ? "filled"+ : "outlined"+ }+ sx={+ !directoryInfo.cameraCalibrationTomlPath+ ? {+ borderColor: theme.palette.grey[400],+ "& .MuiChip-icon": {+ color: theme.palette.grey[600],+ },+ }+ : {}+ }+ />+ </Box>++ {directoryInfo.cameraCalibrationTomlPath && (+ <Box sx={{mt: 1}}>+ <Typography variant="caption" color="text.secondary">+ Found calibration file:+ </Typography>+ <Typography+ variant="caption"+ sx={{+ fontFamily: "monospace",+ display: "block",+ color: "success.main",+ wordBreak: "break-all",+ }}+ >+ {directoryInfo.cameraCalibrationTomlPath}+ </Typography>+ </Box>+ )}+ </Stack>+ </Box>+ )}++ {/* Board Size Configuration */}+ <Stack direction="row" spacing={2}>+ <FormControl size="small" sx={{minWidth: 140}}>+ <InputLabel id="board-preset-label">Preset</InputLabel>+ <Select+ labelId="board-preset-label"+ value={currentPreset}+ label="Preset"+ onChange={(e) =>+ handlePresetChange(e.target.value as BoardPreset)+ }+ disabled={isLoading}+ sx={{color: theme.palette.text.primary}}+ >+ <MenuItem value="5x3">5×3</MenuItem>+ <MenuItem value="7x5">7×5</MenuItem>+ <MenuItem value="custom">Custom</MenuItem>+ </Select>+ </FormControl>+ <TextField+ label="X Squares"+ type="number"+ value={config.charucoBoardXSquares}+ onChange={(e) => handleXSquaresChange(e.target.value)}+ disabled={isLoading}+ size="small"+ sx={{flex: 1}}+ inputProps={{min: 2, max: 20}}+ />+ <TextField+ label="Y Squares"+ type="number"+ value={config.charucoBoardYSquares}+ onChange={(e) => handleYSquaresChange(e.target.value)}+ disabled={isLoading}+ size="small"+ sx={{flex: 1}}+ inputProps={{min: 2, max: 20}}+ />+ </Stack>++ {/* Square Length */}+ <TextField+ label="Square Length (mm)"+ type="number"+ value={config.charucoSquareLength}+ onChange={(e) =>+ updateCalibrationConfig({+ charucoSquareLength: parseFloat(e.target.value) || 0,+ })+ }+ disabled={isLoading}+ size="small"+ fullWidth+ inputProps={{min: 1, step: 0.1}}+ />++ {/* Solver Method & Groundplane */}+ <CalibrationSolverSection />++ {/* Recording Progress */}+ {isRecording && (+ <Box sx={{width: "100%"}}>+ <Typography+ variant="caption"+ color="text.secondary"+ gutterBottom+ >+ Recording in Progress: {recordingProgress.toFixed(0)}%+ </Typography>+ <Box+ sx={{+ width: "100%",+ height: 8,+ bgcolor: "grey.300",+ borderRadius: 1,+ overflow: "hidden",+ }}+ >+ <Box+ sx={{+ width: `${recordingProgress}%`,+ height: "100%",+ bgcolor: theme.palette.primary.main,+ transition: "width 0.3s",+ }}+ />+ </Box>+ </Box>+ )}++ {/* Calibrate Button */}+ <Button+ variant="contained"+ color="secondary"+ onClick={calibrateSelectedRecording}+ disabled={!canCalibrate || isLoading}+ fullWidth+ >+ Calibrate Selected Recording+ </Button>+ </Stack>+ </Box>+ </CollapsibleSidebarSection>+ );+};diff --git a/freemocap-ui/src/components/calibration-control-panel/CalibrationSolverSection.tsx b/freemocap-ui/src/components/calibration-control-panel/CalibrationSolverSection.tsxnew file mode 100644index 00000000..4e2dee23--- /dev/null+++ b/freemocap-ui/src/components/calibration-control-panel/CalibrationSolverSection.tsx@@ -0,0 +1,75 @@+import React from "react";+import {+ FormControl,+ FormControlLabel,+ InputLabel,+ MenuItem,+ Select,+ Stack,+ Switch,+ Typography,+ useTheme,+} from "@mui/material";+import {useCalibration} from "@/hooks/useCalibration";+import {CalibrationSolverMethod} from "@/store/slices/calibration";++/**+ * Calibration solver method and groundplane controls.+ *+ * Drop this into CalibrationControlPanel's Stack, after the+ * square length TextField and before the recording progress section.+ */+export const CalibrationSolverSection: React.FC = () => {+ const theme = useTheme();+ const {config, updateCalibrationConfig, isLoading} = useCalibration();++ return (+ <Stack spacing={2}>+ <Typography+ variant="subtitle2"+ sx={{color: theme.palette.text.secondary, fontWeight: 600}}+ >+ Solver Settings+ </Typography>++ {/* Solver Method */}+ <FormControl size="small" fullWidth>+ <InputLabel id="solver-method-label">Solver Method</InputLabel>+ <Select+ labelId="solver-method-label"+ value={config.solverMethod}+ label="Solver Method"+ onChange={(e) =>+ updateCalibrationConfig({+ solverMethod: e.target.value as CalibrationSolverMethod,+ })+ }+ disabled={isLoading}+ sx={{color: theme.palette.text.primary}}+ >+ <MenuItem value="anipose">Anipose (legacy)</MenuItem>+ <MenuItem value="pyceres">Pyceres (bundle adjustment)</MenuItem>+ </Select>+ </FormControl>++ {/* Groundplane */}+ <FormControlLabel+ control={+ <Switch+ size="small"+ checked={config.useGroundplane}+ onChange={(_, checked) =>+ updateCalibrationConfig({useGroundplane: checked})+ }+ disabled={isLoading}+ />+ }+ label={+ <Typography variant="body2">+ Align to ground plane+ </Typography>+ }+ />+ </Stack>+ );+};diff --git a/freemocap-ui/src/components/calibration-task-panel/CalibrationControlPanel.tsx b/freemocap-ui/src/components/calibration-task-panel/CalibrationControlPanel.tsxdeleted file mode 100644index 946c07dd..00000000--- a/freemocap-ui/src/components/calibration-task-panel/CalibrationControlPanel.tsx+++ /dev/null@@ -1,476 +0,0 @@-// components/CalibrationTaskTreeItem.tsx-import React, {useCallback, useEffect, useMemo, useState} from 'react';-import {- Alert,- Box,- Button,- Checkbox,- Chip,- FormControl,- FormControlLabel,- IconButton,- InputAdornment,- InputLabel,- MenuItem,- Select,- Stack,- TextField,- Tooltip,- Typography,- useTheme,-} from '@mui/material';-import {TreeItem} from '@mui/x-tree-view/TreeItem';-import SquareFootIcon from '@mui/icons-material/SquareFoot';-import PlayArrowIcon from '@mui/icons-material/PlayArrow';-import StopIcon from '@mui/icons-material/Stop';-import FolderOpenIcon from '@mui/icons-material/FolderOpen';-import ClearIcon from '@mui/icons-material/Clear';-import CheckCircleIcon from '@mui/icons-material/CheckCircle';-import InfoIcon from '@mui/icons-material/Info';-import CloseIcon from '@mui/icons-material/Close';-import {useCalibration} from '@/hooks/useCalibration';-import {useElectronIPC} from '@/services';-import ExpandMoreIcon from "@mui/icons-material/ExpandMore";-import ChevronRightIcon from "@mui/icons-material/ChevronRight";-import {SimpleTreeView} from "@mui/x-tree-view";--type BoardPreset = '5x3' | '7x5' | 'custom';--interface BoardPresetConfig {- xSquares: number;- ySquares: number;-}--const BOARD_PRESETS: Record<Exclude<BoardPreset, 'custom'>, BoardPresetConfig> = {- '5x3': { xSquares: 5, ySquares: 3 },- '7x5': { xSquares: 7, ySquares: 5 },-};--export const CalibrationControlPanel: React.FC = () => {- const theme = useTheme();- const [localError, setLocalError] = useState<string | null>(null);- const [expandedItems, setExpandedItems] = useState<string[]>([- 'pipeline-main',- 'calibration-intrinsic',- 'calibration-extrinsic',- 'mocap-task'- ]);- const { api } = useElectronIPC();-- const {- config,- error,- isLoading,- isRecording,- recordingProgress,- canStartRecording,- canCalibrate,- calibrationRecordingPath,- directoryInfo,- isUsingManualPath,- updateCalibrationConfig,- dispatchStopCalibrationRecording,- dispatchStartCalibrationRecording,- setManualRecordingPath,- clearManualRecordingPath,- validateDirectory,- calibrateSelectedRecording,- clearError,- } = useCalibration();-- // Validate directory whenever path changes- useEffect(() => {- if (calibrationRecordingPath) {- validateDirectory(calibrationRecordingPath);- }- }, [calibrationRecordingPath, validateDirectory]);-- // Determine current board preset based on config values- const currentPreset = useMemo<BoardPreset>(() => {- for (const [preset, presetConfig] of Object.entries(BOARD_PRESETS)) {- if (- presetConfig.xSquares === config.charucoBoardXSquares &&- presetConfig.ySquares === config.charucoBoardYSquares- ) {- return preset as BoardPreset;- }- }- return 'custom';- }, [config.charucoBoardXSquares, config.charucoBoardYSquares]);-- const handleClearError = useCallback((): void => {- clearError();- setLocalError(null);- }, [clearError]);-- const handlePresetChange = useCallback((preset: BoardPreset): void => {- if (preset === 'custom') {- // Don't change values when switching to custom- return;- }- const presetConfig = BOARD_PRESETS[preset];- updateCalibrationConfig({- charucoBoardXSquares: presetConfig.xSquares,- charucoBoardYSquares: presetConfig.ySquares,- });- }, [updateCalibrationConfig]);-- const handleXSquaresChange = useCallback((value: string): void => {- const numValue = parseInt(value, 10);- if (!isNaN(numValue) && numValue > 0) {- updateCalibrationConfig({- charucoBoardXSquares: numValue,- });- }- }, [updateCalibrationConfig]);-- const handleYSquaresChange = useCallback((value: string): void => {- const numValue = parseInt(value, 10);- if (!isNaN(numValue) && numValue > 0) {- updateCalibrationConfig({- charucoBoardYSquares: numValue,- });- }- }, [updateCalibrationConfig]);-- const handleSelectDirectory = async (): Promise<void> => {- if ( !api) {- console.warn('Electron API not available');- return;- }-- try {- const result: string | null = await api.fileSystem.selectDirectory.mutate();- if (result) {- await setManualRecordingPath(result);- }- } catch (error) {- console.error('Failed to select directory:', error);- setLocalError('Failed to select directory');- }- };-- const handlePathInputChange = async (e: React.ChangeEvent<HTMLInputElement>): Promise<void> => {- const newPath: string = e.target.value;-- // Handle tilde expansion for home directory- if (newPath.includes('~') && api) {- try {- const home: string = await api.fileSystem.getHomeDirectory.query();- const expanded: string = newPath.replace(/^~([\/\\])?/, home ? `${home}$1` : '');- await setManualRecordingPath(expanded);- } catch (error) {- console.error('Failed to expand home directory:', error);- await setManualRecordingPath(newPath);- }- } else {- await setManualRecordingPath(newPath);- }- };-- const handleClearManualPath = useCallback((): void => {- clearManualRecordingPath();- }, [clearManualRecordingPath]);-- const displayError = error || localError || directoryInfo?.errorMessage;-- // Helper text for the path input- const pathHelperText = useMemo(() => {- if (isUsingManualPath) {- return 'Using custom path';- }- return 'Using default recording directory';- }, [isUsingManualPath]);- const handleExpandedItemsChange = (- event: React.SyntheticEvent,- itemIds: string[]- ): void => {- setExpandedItems(itemIds);- };- return (- <SimpleTreeView- expandedItems={expandedItems}- onExpandedItemsChange={handleExpandedItemsChange}- slots={{- collapseIcon: ExpandMoreIcon,- expandIcon: ChevronRightIcon,- }}- sx={{ flexGrow: 1 }}- >- <TreeItem- itemId="calibration-task"- label={- <Box sx={{ display: 'flex', alignItems: 'center', py: 1, pr: 1 }}>- <SquareFootIcon sx={{ mr: 1, color: theme.palette.secondary.main }} />- <Typography variant="subtitle1" sx={{ flexGrow: 1 }}>- Capture Volume Calibration- </Typography>- </Box>- }- >- <Box sx={{ p: 2, bgcolor: 'background.paper' }}>- <Stack spacing={2}>- {/* Error Display */}- {displayError && (- <Alert severity="error" onClose={handleClearError}>- {displayError}- </Alert>- )}-- {/* Calibration Recording Path Input */}- <Box>- {/* Live Tracker Toggle */}- <FormControlLabel- control={- <Checkbox- checked={config.liveTrackCharuco}- onChange={(e) => updateCalibrationConfig({ liveTrackCharuco: e.target.checked })}- disabled={isLoading}- sx={{ '&.Mui-checked': { color: theme.palette.text.primary } }}- />- }- label="Live Track Charuco Board"- />- {/* Recording Controls */}- <Stack direction="row" spacing={2} sx={{ mb: 2 }}>- <Button- variant="contained"- color="primary"- startIcon={<PlayArrowIcon />}- onClick={dispatchStartCalibrationRecording}- disabled={!canStartRecording || isLoading}- fullWidth- >- Start Calibration Recording- </Button>- {isRecording && (- <Button- variant="contained"- color="error"- startIcon={<StopIcon />}- onClick={dispatchStopCalibrationRecording}- disabled={isLoading}- fullWidth- >- Stop Recording- </Button>- )}- </Stack>- <TextField- label="Calibration Recording Path"- value={calibrationRecordingPath}- onChange={handlePathInputChange}- fullWidth- size="small"- helperText={pathHelperText}- InputProps={{- endAdornment: (- <InputAdornment position="end">- {isUsingManualPath && (- <Tooltip title="Clear manual path (revert to default)">- <IconButton- onClick={handleClearManualPath}- edge="end"- size="small"- >- <ClearIcon fontSize="small" />- </IconButton>- </Tooltip>- )}- <Tooltip title="Select directory">- <IconButton- onClick={handleSelectDirectory}- edge="end"- >- <FolderOpenIcon />- </IconButton>- </Tooltip>- </InputAdornment>- ),- }}- />- </Box>-- {/* Directory Status Info */}- {directoryInfo && (- <Box sx={{- p: 1.5,- borderRadius: 1,- border: `2px solid ${theme.palette.divider}`- }}>- <Stack spacing={1}>- <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>- <InfoIcon fontSize="small" color="info" />- <Typography variant="caption" fontWeight="medium">- Calibration Folder Status- </Typography>- </Box>-- <Box sx={{ display: 'flex', gap: 1, flexWrap: 'wrap' }}>- <Chip- label={directoryInfo.exists ? "Directory exists" : "Directory will be created"}- size="small"- color={directoryInfo.exists ? "success" : "default"}- icon={directoryInfo.exists ? <CheckCircleIcon /> : <CloseIcon />}- variant={directoryInfo.exists ? "filled" : "outlined"}- sx={!directoryInfo.exists ? {- borderColor: theme.palette.grey[400],- '& .MuiChip-icon': { color: theme.palette.grey[600] }- } : {}}- />-- <Chip- label="Has videos"- size="small"- color={directoryInfo.hasVideos ? "success" : "default"}- icon={directoryInfo.hasVideos ? <CheckCircleIcon /> : <CloseIcon />}- variant={directoryInfo.hasVideos ? "filled" : "outlined"}- sx={!directoryInfo.hasVideos ? {- borderColor: theme.palette.grey[400],- '& .MuiChip-icon': { color: theme.palette.grey[600] }- } : {}}- />-- <Chip- label="Has synchronized_videos"- size="small"- color={directoryInfo.hasSynchronizedVideos ? "success" : "default"}- icon={directoryInfo.hasSynchronizedVideos ? <CheckCircleIcon /> : <CloseIcon />}- variant={directoryInfo.hasSynchronizedVideos ? "filled" : "outlined"}- sx={!directoryInfo.hasSynchronizedVideos ? {- borderColor: theme.palette.grey[400],- '& .MuiChip-icon': { color: theme.palette.grey[600] }- } : {}}- />-- <Chip- label="Has calibration TOML"- size="small"- color={directoryInfo.cameraCalibrationTomlPath ? "success" : "default"}- icon={directoryInfo.cameraCalibrationTomlPath ? <CheckCircleIcon /> : <CloseIcon />}- variant={directoryInfo.cameraCalibrationTomlPath ? "filled" : "outlined"}- sx={!directoryInfo.cameraCalibrationTomlPath ? {- borderColor: theme.palette.grey[400],- '& .MuiChip-icon': { color: theme.palette.grey[600] }- } : {}}- />- </Box>-- {directoryInfo.cameraCalibrationTomlPath && (- <Box sx={{ mt: 1 }}>- <Typography variant="caption" color="text.secondary">- Found calibration file:- </Typography>- <Typography- variant="caption"- sx={{- fontFamily: 'monospace',- display: 'block',- color: 'success.main',- wordBreak: 'break-all'- }}- >- {directoryInfo.cameraCalibrationTomlPath}- </Typography>- </Box>- )}- </Stack>- </Box>- )}-- {/* Board Size Configuration - All on one row */}- <Stack direction="row" spacing={2}>- <FormControl size="small" sx={{ minWidth: 140 }}>- <InputLabel id="board-preset-label">Preset</InputLabel>- <Select- labelId="board-preset-label"- value={currentPreset}- label="Preset"- onChange={(e) => handlePresetChange(e.target.value as BoardPreset)}- disabled={isLoading}- sx={{color: theme.palette.text.primary}}- >- <MenuItem value="5x3">5×3</MenuItem>- <MenuItem value="7x5">7×5</MenuItem>- <MenuItem value="custom">Custom</MenuItem>- </Select>- </FormControl>- <TextField- label="X Squares"- type="number"- value={config.charucoBoardXSquares}- onChange={(e) => handleXSquaresChange(e.target.value)}- disabled={isLoading}- size="small"- sx={{ flex: 1 }}- inputProps={{ min: 2, max: 20 }}- />- <TextField- label="Y Squares"- type="number"- value={config.charucoBoardYSquares}- onChange={(e) => handleYSquaresChange(e.target.value)}- disabled={isLoading}- size="small"- sx={{ flex: 1 }}- inputProps={{ min: 2, max: 20 }}- />- </Stack>-- {/* Square Length */}- <TextField- label="Square Length (mm)"- type="number"- value={config.charucoSquareLength}- onChange={(e) => updateCalibrationConfig({- charucoSquareLength: parseFloat(e.target.value) || 0- })}- disabled={isLoading}- size="small"- fullWidth- inputProps={{ min: 1, step: 0.1 }}- />-- {/* Recording Progress */}- {isRecording && (- <Box sx={{ width: '100%' }}>- <Typography variant="caption" color="text.secondary" gutterBottom>- Recording in Progress: {recordingProgress.toFixed(0)}%- </Typography>- <Box- sx={{- width: '100%',- height: 8,- bgcolor: 'grey.300',- borderRadius: 1,- overflow: 'hidden',- }}- >- <Box- sx={{- width: `${recordingProgress}%`,- height: '100%',- bgcolor: theme.palette.primary.main,- transition: 'width 0.3s',- }}- />- </Box>- </Box>- )}-- {/* Calibrate Button */}- <Button- variant="contained"- color="secondary"- onClick={calibrateSelectedRecording}- disabled={!canCalibrate || isLoading}- fullWidth- >- Calibrate Selected Recording- </Button>- </Stack>- </Box>- </TreeItem>- </SimpleTreeView>- );-};diff --git a/freemocap-ui/src/components/camera-config-tree-view/CameraConfigTreeView.tsx b/freemocap-ui/src/components/camera-config-tree-view/CameraConfigTreeView.tsxindex ed189217..9a6df270 100644--- a/freemocap-ui/src/components/camera-config-tree-view/CameraConfigTreeView.tsx+++ b/freemocap-ui/src/components/camera-config-tree-view/CameraConfigTreeView.tsx@@ -1,60 +1,56 @@import React, {useEffect, useState} from "react";-import {Paper, useTheme,} from "@mui/material";+import {Box, Chip, Typography, useTheme} from "@mui/material";import {SimpleTreeView} from "@mui/x-tree-view/SimpleTreeView";-import {TreeItem} from "@mui/x-tree-view/TreeItem";import ExpandMore from "@mui/icons-material/ExpandMore";import ChevronRight from "@mui/icons-material/ChevronRight";-import VideoCameraFrontIcon from '@mui/icons-material/VideoCameraFront';+import VideocamIcon from "@mui/icons-material/Videocam";+import VideoCameraFrontIcon from "@mui/icons-material/VideoCameraFront";-import {CameraConfigTreeViewHeader} from "./CameraConfigTreeViewHeader";+import {CollapsibleSidebarSection} from "@/components/common/CollapsibleSidebarSection";+import {CameraHeaderActions} from "./CameraHeaderActions";import {CameraGroupTreeItem} from "./CameraGroupTreeItem";-import {NoCamerasPlaceholder} from "./NoCamerasPlaceholder";import {Camera,detectCameras,selectCameras,selectConnectedCameras,- selectIsLoading,- selectSelectedCameras,+ selectIsLoading, selectSelectedCameras,useAppDispatch,- useAppSelector+ useAppSelector,} from "@/store";-import {useServer} from "@/hooks/useServer";-export const CameraConfigTreeView: React.FC = () => {const theme = useTheme();const dispatch = useAppDispatch();- const {isConnected} = useServer()- // Redux state+ const {isConnected} = useServer();+const cameras = useAppSelector(selectCameras);const isLoading = useAppSelector(selectIsLoading);const connectedCameras = useAppSelector(selectConnectedCameras);const selectedCameras = useAppSelector(selectSelectedCameras);- // Local state+ // Expand state for the inner camera group treeconst [expandedItems, setExpandedItems] = useState<string[]>([- "cameras-root","cameras-connected",- "cameras-available"+ "cameras-available",]);const [isPaused, setIsPaused] = useState<boolean>(false);- // Group cameras by status- const availableCameras = cameras.filter((cam: Camera) => cam.connectionStatus !== "connected");+ const availableCameras = cameras.filter(+ (cam: Camera) => cam.connectionStatus !== "connected"+ );const isConnectedToCameras = connectedCameras.length > 0;- const hasSelectedCameras = selectedCameras.length > 0;- // Initial camera detection+ // Detect cameras on initial connectionuseEffect(() => {- if (isConnected && cameras.length === 0) {- dispatch(detectCameras({ filterVirtual: true }));+ if (isConnected && cameras.length === 0) {+ dispatch(detectCameras({filterVirtual: true}));}}, [isConnected, cameras.length, dispatch]);const handleExpandedItemsChange = (- event: React.SyntheticEvent,+ _event: React.SyntheticEvent,itemIds: string[]): void => {setExpandedItems(itemIds);@@ -64,65 +60,97 @@ export const CameraConfigTreeView: React.FC = () => {setIsPaused(!isPaused);};+ // Build summary content: camera count chips+ const summaryChips = (+ <Box sx={{display: "flex", gap: 0.5, alignItems: "center"}}>+ {connectedCameras.length > 0 && (+ <Chip+ label={`${connectedCameras.length} connected`}+ size="small"+ sx={{+ height: 18,+ fontSize: 10,+ fontWeight: 600,+ backgroundColor: theme.palette.success.main,+ color: theme.palette.getContrastText(theme.palette.success.main),+ }}+ />+ )}+ {cameras.length > 0 && connectedCameras.length === 0 && (+ <Chip+ label={`${cameras.length} detected`}+ size="small"+ variant="outlined"+ sx={{+ height: 18,+ fontSize: 10,+ borderColor: "rgba(255,255,255,0.4)",+ color: "inherit",+ }}+ />+ )}+ </Box>+ );return (- <Paper- elevation={3}- sx={{- borderRadius: 2,- overflow: "hidden",- }}+ <CollapsibleSidebarSection+ icon={<VideocamIcon sx={{color: "inherit"}} />}+ title="Cameras"+ summaryContent={summaryChips}+ primaryControl={+ <CameraHeaderActions+ isLoading={isLoading}+ isPaused={isPaused}+ onPauseToggle={handlePauseToggle}+ />+ }+ defaultExpanded={true}>- <SimpleTreeView- expandedItems={expandedItems}- onExpandedItemsChange={handleExpandedItemsChange}- slots={{- collapseIcon: ExpandMore,- expandIcon: ChevronRight,- }}- >- <TreeItem- itemId="cameras-root"- label={- <CameraConfigTreeViewHeader- cameraCount={cameras.length}- isConnected={isConnectedToCameras}- isLoading={isLoading}- isPaused={isPaused}- onPauseToggle={handlePauseToggle}- hasSelectedCameras={hasSelectedCameras}- />- }+ {cameras.length === 0 ? (+ <Box sx={{p: 3, textAlign: "center"}}>+ <Typography variant="body2" color="text.secondary">+ No cameras detected+ </Typography>+ <Typography+ variant="caption"+ color="text.disabled"+ sx={{mt: 1, display: "block"}}+ >+ Click refresh to scan for available cameras+ </Typography>+ </Box>+ ) : (+ <SimpleTreeView+ expandedItems={expandedItems}+ onExpandedItemsChange={handleExpandedItemsChange}+ slots={{+ collapseIcon: ExpandMore,+ expandIcon: ChevronRight,+ }}>- {cameras.length === 0 ? (- <NoCamerasPlaceholder />- ) : (- <>- {/* Connected Cameras Group */}- {isConnectedToCameras && connectedCameras.length > 0 && (- <CameraGroupTreeItem- groupId="cameras-connected"- title="Connected Cameras"- cameras={connectedCameras}- icon={<VideoCameraFrontIcon color="success" />}- expandedItems={expandedItems}- />- )}+ {/* Connected Cameras Group */}+ {isConnectedToCameras && connectedCameras.length > 0 && (+ <CameraGroupTreeItem+ groupId="cameras-connected"+ title="Connected Cameras"+ cameras={connectedCameras}+ icon={<VideoCameraFrontIcon color="success" />}+ expandedItems={expandedItems}+ />+ )}- {/* Available Cameras Group */}- {availableCameras.length > 0 && (- <CameraGroupTreeItem- groupId="cameras-available"- title="Available Cameras"- cameras={availableCameras}- icon={<VideoCameraFrontIcon color="info" />}- expandedItems={expandedItems}- />- )}- </>+ {/* Available Cameras Group */}+ {availableCameras.length > 0 && (+ <CameraGroupTreeItem+ groupId="cameras-available"+ title="Available Cameras"+ cameras={availableCameras}+ icon={<VideoCameraFrontIcon color="info" />}+ expandedItems={expandedItems}+ />)}- </TreeItem>- </SimpleTreeView>- </Paper>+ </SimpleTreeView>+ )}+ </CollapsibleSidebarSection>);};diff --git a/freemocap-ui/src/components/camera-config-tree-view/CameraConfigTreeView.tsx~ b/freemocap-ui/src/components/camera-config-tree-view/CameraConfigTreeView.tsx~new file mode 100644index 00000000..e9b60471--- /dev/null+++ b/freemocap-ui/src/components/camera-config-tree-view/CameraConfigTreeView.tsx~@@ -0,0 +1,146 @@+import React, {useEffect, useState} from "react";+import {Box, Chip, useTheme} from "@mui/material";+import {SimpleTreeView} from "@mui/x-tree-view/SimpleTreeView";+import ExpandMore from "@mui/icons-material/ExpandMore";+import ChevronRight from "@mui/icons-material/ChevronRight";+import VideocamIcon from "@mui/icons-material/Videocam";+import VideoCameraFrontIcon from "@mui/icons-material/VideoCameraFront";++import {CollapsibleSidebarSection} from "@/components/common/CollapsibleSidebarSection";+import {CameraHeaderActions} from "./CameraHeaderActions";+import {CameraGroupTreeItem} from "./CameraGroupTreeItem";+import {NoCamerasPlaceholder} from "./NoCamerasPlaceholder";+import {+ Camera,+ detectCameras,+ selectCameras,+ selectConnectedCameras,+ selectIsLoading, selectSelectedCameras,+ useAppDispatch,+ useAppSelector,+} from "@/store";+import {useServer} from "@/hooks/useServer";++export const CameraConfigTreeView: React.FC = () => {+ const theme = useTheme();+ const dispatch = useAppDispatch();+ const {isConnected} = useServer();++ const cameras = useAppSelector(selectCameras);+ const isLoading = useAppSelector(selectIsLoading);+ const connectedCameras = useAppSelector(selectConnectedCameras);+ const selectedCameras = useAppSelector(selectSelectedCameras);++ // Expand state for the inner camera group tree+ const [expandedItems, setExpandedItems] = useState<string[]>([+ "cameras-connected",+ "cameras-available",+ ]);+ const [isPaused, setIsPaused] = useState<boolean>(false);++ const availableCameras = cameras.filter(+ (cam: Camera) => cam.connectionStatus !== "connected"+ );+ const isConnectedToCameras = connectedCameras.length > 0;++ // Detect cameras on initial connection+ useEffect(() => {+ if (isConnected && cameras.length === 0) {+ dispatch(detectCameras({filterVirtual: true}));+ }+ }, [isConnected, cameras.length, dispatch]);++ const handleExpandedItemsChange = (+ _event: React.SyntheticEvent,+ itemIds: string[]+ ): void => {+ setExpandedItems(itemIds);+ };++ const handlePauseToggle = (): void => {+ setIsPaused(!isPaused);+ };++ // Build summary content: camera count chips+ const summaryChips = (+ <Box sx={{display: "flex", gap: 0.5, alignItems: "center"}}>+ {connectedCameras.length > 0 && (+ <Chip+ label={`${connectedCameras.length} connected`}+ size="small"+ sx={{+ height: 18,+ fontSize: 10,+ fontWeight: 600,+ backgroundColor: theme.palette.success.main,+ color: theme.palette.getContrastText(theme.palette.success.main),+ }}+ />+ )}+ {cameras.length > 0 && connectedCameras.length === 0 && (+ <Chip+ label={`${cameras.length} detected`}+ size="small"+ variant="outlined"+ sx={{+ height: 18,+ fontSize: 10,+ borderColor: "rgba(255,255,255,0.4)",+ color: "inherit",+ }}+ />+ )}+ </Box>+ );++ return (+ <CollapsibleSidebarSection+ icon={<VideocamIcon sx={{color: "inherit"}} />}+ title="Cameras"+ summaryContent={summaryChips}+ primaryControl={+ <CameraHeaderActions+ isLoading={isLoading}+ isPaused={isPaused}+ onPauseToggle={handlePauseToggle}+ />+ }+ defaultExpanded={true}+ >+ {cameras.length === 0 ? (+ <NoCamerasPlaceholder />+ ) : (+ <SimpleTreeView+ expandedItems={expandedItems}+ onExpandedItemsChange={handleExpandedItemsChange}+ slots={{+ collapseIcon: ExpandMore,+ expandIcon: ChevronRight,+ }}+ >+ {/* Connected Cameras Group */}+ {isConnectedToCameras && connectedCameras.length > 0 && (+ <CameraGroupTreeItem+ groupId="cameras-connected"+ title="Connected Cameras"+ cameras={connectedCameras}+ icon={<VideoCameraFrontIcon color="success" />}+ expandedItems={expandedItems}+ />+ )}++ {/* Available Cameras Group */}+ {availableCameras.length > 0 && (+ <CameraGroupTreeItem+ groupId="cameras-available"+ title="Available Cameras"+ cameras={availableCameras}+ icon={<VideoCameraFrontIcon color="info" />}+ expandedItems={expandedItems}+ />+ )}+ </SimpleTreeView>+ )}+ </CollapsibleSidebarSection>+ );+};diff --git a/freemocap-ui/src/components/camera-config-tree-view/CameraHeaderActions.tsx b/freemocap-ui/src/components/camera-config-tree-view/CameraHeaderActions.tsxnew file mode 100644index 00000000..0cfc4016--- /dev/null+++ b/freemocap-ui/src/components/camera-config-tree-view/CameraHeaderActions.tsx@@ -0,0 +1,154 @@+import React, {useState} from "react";+import {CircularProgress, IconButton, Stack, Tooltip} from "@mui/material";+import VideocamIcon from "@mui/icons-material/Videocam";+import VideocamOffIcon from "@mui/icons-material/VideocamOff";+import PauseIcon from "@mui/icons-material/Pause";+import PlayArrowIcon from "@mui/icons-material/PlayArrow";+import YoutubeSearchedForIcon from "@mui/icons-material/YoutubeSearchedFor";+import {+ camerasConnectOrUpdate,+ closeCameras,+ pauseUnpauseCameras,+ useAppDispatch,+ useAppSelector,+} from "@/store";+import {selectSelectedCameras} from "@/store/slices/cameras/cameras-selectors";+import {detectCameras} from "@/store/slices/cameras/cameras-thunks";++interface CameraHeaderActionsProps {+ isLoading: boolean;+ isPaused: boolean;+ onPauseToggle: () => void;+}++export const CameraHeaderActions: React.FC<CameraHeaderActionsProps> = ({+ isLoading,+ isPaused,+ onPauseToggle,+}) => {+ const dispatch = useAppDispatch();+ const selectedCameras = useAppSelector(selectSelectedCameras);+ const hasSelected = selectedCameras.length > 0;+ const [isActionInProgress, setIsActionInProgress] = useState(false);++ const handleRefreshCameras = async (e: React.MouseEvent): Promise<void> => {+ e.stopPropagation();+ setIsActionInProgress(true);+ try {+ await dispatch(detectCameras({filterVirtual: true})).unwrap();+ } catch (error) {+ console.error("Error detecting cameras:", error);+ } finally {+ setIsActionInProgress(false);+ }+ };++ const handleConnectOrApply = async (e: React.MouseEvent): Promise<void> => {+ e.stopPropagation();+ setIsActionInProgress(true);+ try {+ await dispatch(camerasConnectOrUpdate()).unwrap();+ } catch (error) {+ console.error("Error with camera operation:", error);+ } finally {+ setIsActionInProgress(false);+ }+ };++ const handleCloseCameras = async (e: React.MouseEvent): Promise<void> => {+ e.stopPropagation();+ setIsActionInProgress(true);+ try {+ await dispatch(closeCameras()).unwrap();+ } catch (error) {+ console.error("Error closing cameras:", error);+ } finally {+ setIsActionInProgress(false);+ }+ };++ const handlePauseUnpause = async (e: React.MouseEvent): Promise<void> => {+ e.stopPropagation();+ setIsActionInProgress(true);+ try {+ await dispatch(pauseUnpauseCameras()).unwrap();+ onPauseToggle();+ } catch (error) {+ console.error("Error pausing/unpausing cameras:", error);+ } finally {+ setIsActionInProgress(false);+ }+ };++ const iconButtonSx = {+ color: "inherit",+ "&:hover": {+ backgroundColor: "rgba(255,255,255,0.1)",+ },+ };++ return (+ <Stack direction="row" spacing={0.5}>+ {/* Connect/Apply */}+ <Tooltip title="Connect selected cameras or apply config updates">+ <span>+ <IconButton+ size="small"+ onClick={handleConnectOrApply}+ disabled={!hasSelected}+ sx={iconButtonSx}+ >+ <VideocamIcon fontSize="small" />+ </IconButton>+ </span>+ </Tooltip>++ {/* Pause/Resume */}+ <Tooltip title={isPaused ? "Resume streaming" : "Pause streaming"}>+ <span>+ <IconButton+ size="small"+ onClick={handlePauseUnpause}+ sx={iconButtonSx}+ >+ {isPaused ? (+ <PlayArrowIcon fontSize="small" />+ ) : (+ <PauseIcon fontSize="small" />+ )}+ </IconButton>+ </span>+ </Tooltip>++ {/* Close All */}+ <Tooltip title="Close all cameras">+ <span>+ <IconButton+ size="small"+ onClick={handleCloseCameras}+ sx={iconButtonSx}+ >+ <VideocamOffIcon fontSize="small" />+ </IconButton>+ </span>+ </Tooltip>++ {/* Detect/Refresh */}+ <Tooltip title="Detect available cameras">+ <span>+ <IconButton+ size="small"+ onClick={handleRefreshCameras}+ sx={iconButtonSx}+ >+ {isLoading || isActionInProgress ? (+ <CircularProgress size={18} sx={{color: "inherit"}} />+ ) : (+ <YoutubeSearchedForIcon fontSize="small" />+ )}+ </IconButton>+ </span>+ </Tooltip>+ </Stack>+ );+};diff --git a/freemocap-ui/src/components/camera-views/CameraViewsGrid.tsx b/freemocap-ui/src/components/camera-views/CameraViewsGrid.tsxindex 24d5c1f4..b134b423 100644--- a/freemocap-ui/src/components/camera-views/CameraViewsGrid.tsx+++ b/freemocap-ui/src/components/camera-views/CameraViewsGrid.tsx@@ -3,28 +3,20 @@ import {Box} from "@mui/material";import {Panel, PanelGroup, PanelResizeHandle} from "react-resizable-panels";import {useTheme} from "@mui/material/styles";import {CameraView} from "./CameraView";-import {useServer} from "@/hooks/useServer";--interface CameraSettings {- columns: number | null;-}--interface CameraViewsGridProps {- settings?: CameraSettings;-}+import {CameraSettings} from "@/pages/CamerasPage";interface CameraViewsGridProps {- settings?: CameraSettings;- resetKey?: number;+ settings: CameraSettings;+ resetKey: number;}-export const CameraViewsGrid: React.FC<CameraViewsGridProps> = ({ settings, resetKey }) => {+export const CameraViewsGrid: React.FC<CameraViewsGridProps> = ({settings, resetKey}) => {const theme = useTheme();- const { connectedCameraIds } = useServer();+ const {connectedCameraIds} = useServer();const getColumns = (total: number): number => {- if (settings?.columns !== null && settings?.columns !== undefined) {+ if (settings.columns !== null && settings.columns !== undefined) {return settings.columns;}@@ -49,7 +41,7 @@ export const CameraViewsGrid: React.FC<CameraViewsGridProps> = ({ settings, rese}}><div><div>No cameras connected</div>- <div style={{ fontSize: '0.9rem', marginTop: '0.5rem' }}>+ <div style={{fontSize: '0.9rem', marginTop: '0.5rem'}}>Waiting for camera streams...</div></div>@@ -65,7 +57,6 @@ export const CameraViewsGrid: React.FC<CameraViewsGridProps> = ({ settings, reserows.push(connectedCameraIds.slice(i, i + columns));}- // Calculate default size for each panelconst defaultRowSize = 100 / rows.length;const minRowSize = Math.max(10, 100 / (rows.length * 2));@@ -76,7 +67,7 @@ export const CameraViewsGrid: React.FC<CameraViewsGridProps> = ({ settings, reseoverflow: 'hidden',padding: 1,}}>- <PanelGroup key={`camera-grid-${resetKey ?? 0}`} direction="vertical">+ <PanelGroup key={`camera-grid-${resetKey}`} direction="vertical">{rows.map((row, rowIndex) => {const defaultCameraSize = 100 / row.length;const minCameraSize = Math.max(10, 100 / (row.length * 2));@@ -102,7 +93,7 @@ export const CameraViewsGrid: React.FC<CameraViewsGridProps> = ({ settings, resejustifyContent: 'center',overflow: 'hidden',}}>- <CameraView cameraId={cameraId} />+ <CameraView cameraId={cameraId}/></Box></Panel>@@ -137,4 +128,4 @@ export const CameraViewsGrid: React.FC<CameraViewsGridProps> = ({ settings, rese</PanelGroup></Box>);-};+};\ No newline at end of filediff --git a/freemocap-ui/src/components/camera-views/camera-view-settings-overlay/CamerasViewSettingsOverlay.tsx b/freemocap-ui/src/components/camera-views/camera-view-settings-overlay/CamerasViewSettingsOverlay.tsxindex 58e29fca..4fb911aa 100644--- a/freemocap-ui/src/components/camera-views/camera-view-settings-overlay/CamerasViewSettingsOverlay.tsx+++ b/freemocap-ui/src/components/camera-views/camera-view-settings-overlay/CamerasViewSettingsOverlay.tsx@@ -1,17 +1,14 @@import React, {useState} from 'react';-import {Box, Button, Checkbox, FormControlLabel, IconButton, Paper, TextField, Tooltip} from '@mui/material';+import {Box, Button, Checkbox, FormControlLabel, IconButton, Paper, TextField, ToggleButton, ToggleButtonGroup, Tooltip} from '@mui/material';import SettingsIcon from '@mui/icons-material/Settings';import CloseIcon from '@mui/icons-material/Close';import GridViewIcon from '@mui/icons-material/GridView';import ViewInArIcon from '@mui/icons-material/ViewInAr';import RestartAltIcon from '@mui/icons-material/RestartAlt';-+import ViewColumnIcon from '@mui/icons-material/ViewColumn';+import TableRowsIcon from '@mui/icons-material/TableRows';import {useServer} from "@/hooks/useServer";--interface CameraSettings {- columns: number | null;- show3dView: boolean;-}+import {CameraSettings, LayoutDirection} from "@/pages/CamerasPage";interface CamerasViewSettingsOverlayProps {onSettingsChange: (settings: CameraSettings) => void;@@ -22,11 +19,12 @@ export const CamerasViewSettingsOverlay: React.FC<CamerasViewSettingsOverlayProponSettingsChange,onResetViews}) => {- const { connectedCameraIds } = useServer();+ const {connectedCameraIds} = useServer();const [isOpen, setIsOpen] = useState<boolean>(false);const [isAuto, setIsAuto] = useState<boolean>(true);const [manualColumns, setManualColumns] = useState<number>(2);const [show3dView, setShow3dView] = useState<boolean>(true);+ const [layoutDirection, setLayoutDirection] = useState<LayoutDirection>('horizontal');const getAutoColumns = (total: number): number => {if (total <= 1) return 1;@@ -37,13 +35,20 @@ export const CamerasViewSettingsOverlay: React.FC<CamerasViewSettingsOverlayPropconst autoColumns = getAutoColumns(connectedCameraIds.length);+ const buildSettings = (overrides: Partial<{+ columns: number | null;+ show3dView: boolean;+ layoutDirection: LayoutDirection;+ }> = {}): CameraSettings => ({+ columns: overrides.columns !== undefined ? overrides.columns : (isAuto ? null : manualColumns),+ show3dView: overrides.show3dView !== undefined ? overrides.show3dView : show3dView,+ layoutDirection: overrides.layoutDirection !== undefined ? overrides.layoutDirection : layoutDirection,+ });+const handleAutoChange = (event: React.ChangeEvent<HTMLInputElement>) => {const checked = event.target.checked;setIsAuto(checked);- onSettingsChange({- columns: checked ? null : manualColumns,- show3dView- });+ onSettingsChange(buildSettings({columns: checked ? null : manualColumns}));};const handleColumnsChange = (event: React.ChangeEvent<HTMLInputElement>) => {@@ -51,23 +56,22 @@ export const CamerasViewSettingsOverlay: React.FC<CamerasViewSettingsOverlayPropif (!isNaN(value) && value > 0) {setManualColumns(value);if (isAuto) {- // User is adjusting input while Auto is checked, so uncheck AutosetIsAuto(false);}- onSettingsChange({- columns: value,- show3dView- });+ onSettingsChange(buildSettings({columns: value}));}};const handle3dViewChange = (event: React.ChangeEvent<HTMLInputElement>) => {const checked = event.target.checked;setShow3dView(checked);- onSettingsChange({- columns: isAuto ? null : manualColumns,- show3dView: checked- });+ onSettingsChange(buildSettings({show3dView: checked}));+ };++ const handleLayoutDirectionChange = (_event: React.MouseEvent<HTMLElement>, newDirection: LayoutDirection | null) => {+ if (newDirection === null) return; // Prevent deselecting both+ setLayoutDirection(newDirection);+ onSettingsChange(buildSettings({layoutDirection: newDirection}));};const handleResetViews = () => {@@ -96,7 +100,7 @@ export const CamerasViewSettingsOverlay: React.FC<CamerasViewSettingsOverlayProp},}}>- {isOpen ? <CloseIcon /> : <SettingsIcon />}+ {isOpen ? <CloseIcon/> : <SettingsIcon/>}</IconButton></Tooltip></Box>@@ -114,12 +118,12 @@ export const CamerasViewSettingsOverlay: React.FC<CamerasViewSettingsOverlayPropminWidth: 250,}}>- <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 2 }}>- <GridViewIcon fontSize="small" />- <Box sx={{ fontWeight: 600 }}>Grid Columns</Box>+ <Box sx={{display: 'flex', alignItems: 'center', gap: 1, mb: 2}}>+ <GridViewIcon fontSize="small"/>+ <Box sx={{fontWeight: 600}}>Grid Columns</Box></Box>- <Box sx={{ display: 'flex', alignItems: 'flex-start', gap: 1, mb: 3 }}>+ <Box sx={{display: 'flex', alignItems: 'flex-start', gap: 1, mb: 3}}><FormControlLabelcontrol={<Checkbox@@ -149,12 +153,12 @@ export const CamerasViewSettingsOverlay: React.FC<CamerasViewSettingsOverlayProp/></Box>- <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 2 }}>- <ViewInArIcon fontSize="small" />- <Box sx={{ fontWeight: 600 }}>3D View</Box>+ <Box sx={{display: 'flex', alignItems: 'center', gap: 1, mb: 2}}>+ <ViewInArIcon fontSize="small"/>+ <Box sx={{fontWeight: 600}}>3D View</Box></Box>- <Box sx={{ display: 'flex', alignItems: 'flex-start', gap: 1, mb: 3 }}>+ <Box sx={{display: 'flex', alignItems: 'flex-start', gap: 1, mb: 2}}><FormControlLabelcontrol={<Checkbox@@ -171,9 +175,37 @@ export const CamerasViewSettingsOverlay: React.FC<CamerasViewSettingsOverlayProp/></Box>+ {/* Layout direction toggle — only meaningful when 3D view is visible */}+ <Box sx={{+ display: 'flex',+ alignItems: 'center',+ gap: 1,+ mb: 1,+ opacity: show3dView ? 1 : 0.4,+ }}>+ <Box sx={{fontWeight: 600, fontSize: 13}}>Layout</Box>+ </Box>+ <ToggleButtonGroup+ value={layoutDirection}+ exclusive+ onChange={handleLayoutDirectionChange}+ disabled={!show3dView}+ size="small"+ sx={{mb: 3, width: '100%'}}+ >+ <ToggleButton value="vertical" sx={{flex: 1, textTransform: 'none', fontSize: 12}}>+ <TableRowsIcon sx={{mr: 0.5, fontSize: 16}}/>+ Top / Bottom+ </ToggleButton>+ <ToggleButton value="horizontal" sx={{flex: 1, textTransform: 'none', fontSize: 12}}>+ <ViewColumnIcon sx={{mr: 0.5, fontSize: 16}}/>+ Side by Side+ </ToggleButton>+ </ToggleButtonGroup>+<Buttonvariant="outlined"- startIcon={<RestartAltIcon />}+ startIcon={<RestartAltIcon/>}onClick={handleResetViews}fullWidthsx={{@@ -193,4 +225,4 @@ export const CamerasViewSettingsOverlay: React.FC<CamerasViewSettingsOverlayProp)}</>);-};+};\ No newline at end of filediff --git a/freemocap-ui/src/components/common/CollapsibleSidebarSection.tsx b/freemocap-ui/src/components/common/CollapsibleSidebarSection.tsxnew file mode 100644index 00000000..ede732ba--- /dev/null+++ b/freemocap-ui/src/components/common/CollapsibleSidebarSection.tsx@@ -0,0 +1,173 @@+import React, {ReactNode, useCallback, useState} from "react";+import {Box, Collapse, Paper, Typography, useTheme} from "@mui/material";+import ExpandMoreIcon from "@mui/icons-material/ExpandMore";+import ChevronRightIcon from "@mui/icons-material/ChevronRight";+import DragIndicatorIcon from "@mui/icons-material/DragIndicator";+import {useDragHandle} from "@/components/common/DragHandleContext";++interface CollapsibleSidebarSectionProps {+ icon: ReactNode;+ title: string;+ primaryControl: ReactNode;+ summaryContent: ReactNode;+ children: ReactNode;+ defaultExpanded: boolean;+}++export const CollapsibleSidebarSection: React.FC<CollapsibleSidebarSectionProps> = ({+ icon,+ title,+ primaryControl,+ summaryContent,+ children,+ defaultExpanded,+ }) => {+ const theme = useTheme();+ const [expanded, setExpanded] = useState(defaultExpanded);+ const dragHandle = useDragHandle();++ const handleToggle = useCallback(() => {+ setExpanded((prev) => !prev);+ }, []);++ const handlePrimaryControlClick = useCallback((e: React.MouseEvent) => {+ e.stopPropagation();+ }, []);++ return (+ <Paper+ elevation={1}+ sx={{+ borderRadius: 1,+ overflow: "hidden",+ }}+ >+ {/* Header row — always visible, identical whether expanded or collapsed */}+ <Box+ onClick={handleToggle}+ sx={{+ display: "flex",+ alignItems: "center",+ cursor: "pointer",+ py: 0.75,+ px: dragHandle ? 0.5 : 1.5,+ minHeight: 44,+ backgroundColor: theme.palette.primary.main,+ color: theme.palette.primary.contrastText,+ userSelect: "none",+ transition: "background-color 0.15s ease",+ "&:hover": {+ backgroundColor: theme.palette.primary.dark,+ },+ }}+ >+ {/* Drag handle — only rendered when inside a sortable context */}+ {dragHandle && (+ <Box+ {...dragHandle.attributes}+ {...dragHandle.listeners}+ onClick={(e: React.MouseEvent) => e.stopPropagation()}+ sx={{+ display: "flex",+ alignItems: "center",+ cursor: "grab",+ px: 0.25,+ mr: 0.25,+ flexShrink: 0,+ opacity: 0.35,+ borderRadius: 0.5,+ transition: "opacity 0.15s ease, background-color 0.15s ease",+ "&:hover": {+ opacity: 0.9,+ backgroundColor: "rgba(255,255,255,0.1)",+ },+ "&:active": {+ cursor: "grabbing",+ },+ }}+ >+ <DragIndicatorIcon sx={{fontSize: 18}} />+ </Box>+ )}++ {/* Expand/collapse chevron */}+ <Box+ sx={{+ display: "flex",+ alignItems: "center",+ mr: 0.5,+ flexShrink: 0,+ }}+ >+ {expanded ? (+ <ExpandMoreIcon fontSize="small" />+ ) : (+ <ChevronRightIcon fontSize="small" />+ )}+ </Box>++ {/* Section icon */}+ <Box+ sx={{+ display: "flex",+ alignItems: "center",+ mr: 1,+ flexShrink: 0,+ }}+ >+ {icon}+ </Box>++ {/* Title */}+ <Typography+ variant="subtitle1"+ sx={{+ fontWeight: 600,+ flexShrink: 0,+ lineHeight: 1.3,+ }}+ >+ {title}+ </Typography>++ {/* Summary — fills remaining horizontal space */}+ <Box+ sx={{+ flexGrow: 1,+ mx: 1.5,+ overflow: "hidden",+ display: "flex",+ alignItems: "center",+ justifyContent: "flex-end",+ }}+ >+ {summaryContent}+ </Box>++ {/* Primary control — click is isolated from expand/collapse */}+ <Box+ onClick={handlePrimaryControlClick}+ sx={{+ flexShrink: 0,+ display: "flex",+ alignItems: "center",+ pr: 0.5,+ }}+ >+ {primaryControl}+ </Box>+ </Box>++ {/* Detail panel — only visible when expanded */}+ <Collapse in={expanded} timeout="auto" unmountOnExit>+ <Box+ sx={{+ backgroundColor: theme.palette.background.paper,+ }}+ >+ {children}+ </Box>+ </Collapse>+ </Paper>+ );+};diff --git a/freemocap-ui/src/components/common/DragHandleContext.ts b/freemocap-ui/src/components/common/DragHandleContext.tsnew file mode 100644index 00000000..7d8f9b82--- /dev/null+++ b/freemocap-ui/src/components/common/DragHandleContext.ts@@ -0,0 +1,12 @@+import {createContext, useContext} from "react";++export interface DragHandleContextValue {+ listeners: Record<string, Function> | undefined;+ attributes: Record<string, any>;+}++export const DragHandleContext = createContext<DragHandleContextValue | null>(null);++export const useDragHandle = (): DragHandleContextValue | null => {+ return useContext(DragHandleContext);+};diff --git a/freemocap-ui/src/components/common/SortableSectionWrapper.tsx b/freemocap-ui/src/components/common/SortableSectionWrapper.tsxnew file mode 100644index 00000000..d5ca7140--- /dev/null+++ b/freemocap-ui/src/components/common/SortableSectionWrapper.tsx@@ -0,0 +1,39 @@+import React, {ReactNode} from "react";+import {useSortable} from "@dnd-kit/sortable";+import {CSS} from "@dnd-kit/utilities";+import {DragHandleContext} from "@/components/common/DragHandleContext";++interface SortableSectionWrapperProps {+ id: string;+ children: ReactNode;+}++export const SortableSectionWrapper: React.FC<SortableSectionWrapperProps> = ({+ id,+ children,+}) => {+ const {+ attributes,+ listeners,+ setNodeRef,+ transform,+ transition,+ isDragging,+ } = useSortable({id});++ const style: React.CSSProperties = {+ transform: CSS.Transform.toString(transform),+ transition,+ zIndex: isDragging ? 10 : undefined,+ position: "relative",+ opacity: isDragging ? 0.85 : 1,+ };++ return (+ <div ref={setNodeRef} style={style}>+ <DragHandleContext.Provider value={{listeners, attributes}}>+ {children}+ </DragHandleContext.Provider>+ </div>+ );+};diff --git a/freemocap-ui/src/components/mocap-control-panel/MediapipeConfigPanel.tsx b/freemocap-ui/src/components/mocap-control-panel/MediapipeConfigPanel.tsxnew file mode 100644index 00000000..0916d6a8--- /dev/null+++ b/freemocap-ui/src/components/mocap-control-panel/MediapipeConfigPanel.tsx@@ -0,0 +1,229 @@+import React, {useCallback} from "react";+import {+ Box,+ Chip,+ FormControl,+ FormControlLabel,+ InputLabel,+ MenuItem,+ Select,+ Slider,+ Stack,+ Switch,+ Typography,+ useTheme,+} from "@mui/material";+import {useMocap} from "@/hooks/useMocap";+import {+ MEDIAPIPE_REALTIME_PRESET,+ MEDIAPIPE_POSTHOC_PRESET,+ MediapipeModelComplexity,+} from "@/store/slices/mocap";++const MODEL_COMPLEXITY_LABELS: Record<MediapipeModelComplexity, string> = {+ 0: "Lite (fastest)",+ 1: "Full (balanced)",+ 2: "Heavy (most accurate)",+};++type DetectorPreset = "realtime" | "posthoc" | "custom";++function detectPreset(+ config: { model_complexity: number; enable_segmentation: boolean; smooth_segmentation: boolean }+): DetectorPreset {+ if (+ config.model_complexity === 0 &&+ !config.enable_segmentation &&+ !config.smooth_segmentation+ ) return "realtime";+ if (+ config.model_complexity === 2 &&+ config.enable_segmentation &&+ config.smooth_segmentation+ ) return "posthoc";+ return "custom";+}++/** Shared slider sx that matches the camera config panel style. */+const useSliderSx = () => {+ const theme = useTheme();+ return {+ color: theme.palette.primary.light,+ "& .MuiSlider-thumb": {+ "&:hover, &.Mui-focusVisible": {+ boxShadow: `0px 0px 0px 8px ${theme.palette.primary.light}33`,+ },+ },+ } as const;+};++export const MediapipeConfigPanel: React.FC = () => {+ const theme = useTheme();+ const sliderSx = useSliderSx();+ const {detectorConfig, updateDetectorConfig, replaceDetectorConfig, isLoading} = useMocap();++ const currentPreset = detectPreset(detectorConfig);++ const handlePresetChange = useCallback(+ (preset: DetectorPreset) => {+ if (preset === "realtime") replaceDetectorConfig({...MEDIAPIPE_REALTIME_PRESET});+ else if (preset === "posthoc") replaceDetectorConfig({...MEDIAPIPE_POSTHOC_PRESET});+ },+ [replaceDetectorConfig]+ );++ return (+ <Stack spacing={2}>+ <Typography variant="subtitle2" sx={{color: theme.palette.text.secondary, fontWeight: 600}}>+ MediaPipe Detector+ </Typography>++ {/* Preset selector */}+ <Stack direction="row" spacing={1} alignItems="center">+ <Typography variant="caption" sx={{color: theme.palette.text.secondary, minWidth: 48}}>+ Preset+ </Typography>+ <Chip+ label="Realtime"+ size="small"+ variant={currentPreset === "realtime" ? "filled" : "outlined"}+ color={currentPreset === "realtime" ? "primary" : "default"}+ onClick={() => handlePresetChange("realtime")}+ disabled={isLoading}+ sx={{cursor: "pointer"}}+ />+ <Chip+ label="Posthoc"+ size="small"+ variant={currentPreset === "posthoc" ? "filled" : "outlined"}+ color={currentPreset === "posthoc" ? "primary" : "default"}+ onClick={() => handlePresetChange("posthoc")}+ disabled={isLoading}+ sx={{cursor: "pointer"}}+ />+ {currentPreset === "custom" && (+ <Chip label="Custom" size="small" variant="outlined" color="warning" />+ )}+ </Stack>++ {/* Model complexity */}+ <FormControl size="small" fullWidth>+ <InputLabel id="model-complexity-label">Model Complexity</InputLabel>+ <Select+ labelId="model-complexity-label"+ value={detectorConfig.model_complexity}+ label="Model Complexity"+ onChange={(e) =>+ updateDetectorConfig({+ model_complexity: e.target.value as MediapipeModelComplexity,+ })+ }+ disabled={isLoading}+ sx={{color: theme.palette.text.primary}}+ >+ <MenuItem value={0}>{MODEL_COMPLEXITY_LABELS[0]}</MenuItem>+ <MenuItem value={1}>{MODEL_COMPLEXITY_LABELS[1]}</MenuItem>+ <MenuItem value={2}>{MODEL_COMPLEXITY_LABELS[2]}</MenuItem>+ </Select>+ </FormControl>++ {/* Confidence sliders */}+ <Box>+ <Typography variant="caption" color="text.secondary">+ Min Detection Confidence: {detectorConfig.min_detection_confidence.toFixed(2)}+ </Typography>+ <Slider+ value={detectorConfig.min_detection_confidence}+ onChange={(_ , value) =>+ updateDetectorConfig({min_detection_confidence: value as number})+ }+ min={0} max={1} step={0.05} size="small" disabled={isLoading}+ sx={sliderSx}+ />+ </Box>++ <Box>+ <Typography variant="caption" color="text.secondary">+ Min Tracking Confidence: {detectorConfig.min_tracking_confidence.toFixed(2)}+ </Typography>+ <Slider+ value={detectorConfig.min_tracking_confidence}+ onChange={(_, value) =>+ updateDetectorConfig({min_tracking_confidence: value as number})+ }+ min={0} max={1} step={0.05} size="small" disabled={isLoading}+ sx={sliderSx}+ />+ </Box>++ {/* Boolean toggles */}+ <Stack spacing={0}>+ <FormControlLabel+ control={+ <Switch+ size="small"+ checked={detectorConfig.smooth_landmarks}+ onChange={(_, checked) =>+ updateDetectorConfig({smooth_landmarks: checked})+ }+ disabled={isLoading}+ />+ }+ label={<Typography variant="body2">Smooth Landmarks</Typography>}+ />+ <FormControlLabel+ control={+ <Switch+ size="small"+ checked={detectorConfig.enable_segmentation}+ onChange={(_, checked) =>+ updateDetectorConfig({enable_segmentation: checked})+ }+ disabled={isLoading}+ />+ }+ label={<Typography variant="body2">Enable Segmentation</Typography>}+ />+ <FormControlLabel+ control={+ <Switch+ size="small"+ checked={detectorConfig.smooth_segmentation}+ onChange={(_, checked) =>+ updateDetectorConfig({smooth_segmentation: checked})+ }+ disabled={isLoading || !detectorConfig.enable_segmentation}+ />+ }+ label={<Typography variant="body2">Smooth Segmentation</Typography>}+ />+ <FormControlLabel+ control={+ <Switch+ size="small"+ checked={detectorConfig.refine_face_landmarks}+ onChange={(_, checked) =>+ updateDetectorConfig({refine_face_landmarks: checked})+ }+ disabled={isLoading}+ />+ }+ label={<Typography variant="body2">Refine Face Landmarks</Typography>}+ />+ <FormControlLabel+ control={+ <Switch+ size="small"+ checked={detectorConfig.static_image_mode}+ onChange={(_, checked) =>+ updateDetectorConfig({static_image_mode: checked})+ }+ disabled={isLoading}+ />+ }+ label={<Typography variant="body2">Static Image Mode</Typography>}+ />+ </Stack>+ </Stack>+ );+};diff --git a/freemocap-ui/src/components/mocap-control-panel/MocapTaskTreeItem.tsx b/freemocap-ui/src/components/mocap-control-panel/MocapTaskTreeItem.tsxnew file mode 100644index 00000000..7fe7203b--- /dev/null+++ b/freemocap-ui/src/components/mocap-control-panel/MocapTaskTreeItem.tsx@@ -0,0 +1,476 @@+import React, {useCallback, useMemo, useState} from "react";+import {+ Alert,+ Box,+ Button,+ Chip,+ IconButton,+ InputAdornment,+ Stack,+ TextField,+ Tooltip,+ Typography,+ useTheme,+} from "@mui/material";+import DirectionsRunIcon from "@mui/icons-material/DirectionsRun";+import PlayArrowIcon from "@mui/icons-material/PlayArrow";+import StopIcon from "@mui/icons-material/Stop";+import FolderOpenIcon from "@mui/icons-material/FolderOpen";+import ClearIcon from "@mui/icons-material/Clear";+import CheckCircleIcon from "@mui/icons-material/CheckCircle";+import InfoIcon from "@mui/icons-material/Info";+import CloseIcon from "@mui/icons-material/Close";+import FiberManualRecordIcon from "@mui/icons-material/FiberManualRecord";+import {CollapsibleSidebarSection} from "@/components/common/CollapsibleSidebarSection";+import {useMocap} from "@/hooks/useMocap";+import {useElectronIPC} from "@/services";+import {MediapipeConfigPanel} from "@/components/mocap-control-panel/MediapipeConfigPanel";+import {SkeletonFilterConfigPanel} from "@/components/mocap-control-panel/SkeletonFilterConfigPanel";++export const MocapTaskTreeItem: React.FC = () => {+ const theme = useTheme();+ const [localError, setLocalError] = useState<string | null>(null);+ const {api, isElectron} = useElectronIPC();++ const {+ error,+ isLoading,+ isRecording,+ recordingProgress,+ canStartRecording,+ canProcessMocapRecording,+ mocapRecordingPath,+ directoryInfo,+ isUsingManualPath,+ dispatchStopMocapRecording,+ dispatchStartMocapRecording,+ setManualRecordingPath,+ clearManualRecordingPath,+ dispatchProcessMocapRecording,+ clearError,+ } = useMocap();++ const handleClearError = useCallback((): void => {+ clearError();+ setLocalError(null);+ }, [clearError]);++ const handleSelectDirectory = async (): Promise<void> => {+ if (!isElectron || !api) {+ console.warn("Electron API not available");+ return;+ }+ try {+ const result: string | null = await api.fileSystem.selectDirectory.mutate();+ if (result) {+ await setManualRecordingPath(result);+ }+ } catch (err) {+ console.error("Failed to select directory:", err);+ setLocalError("Failed to select directory");+ }+ };++ const handlePathInputChange = async (+ e: React.ChangeEvent<HTMLInputElement>+ ): Promise<void> => {+ const newPath: string = e.target.value;+ if (newPath.includes("~") && isElectron && api) {+ try {+ const home: string = await api.fileSystem.getHomeDirectory.query();+ const expanded: string = newPath.replace(+ /^~([/\\])?/,+ home ? `${home}$1` : ""+ );+ await setManualRecordingPath(expanded);+ } catch (err) {+ console.error("Failed to expand home directory:", err);+ await setManualRecordingPath(newPath);+ }+ } else {+ await setManualRecordingPath(newPath);+ }+ };++ const handleClearManualPath = useCallback((): void => {+ clearManualRecordingPath();+ }, [clearManualRecordingPath]);++ const displayError = error || localError || directoryInfo?.errorMessage;++ const pathHelperText = useMemo(() => {+ if (isUsingManualPath) return "Using custom path";+ return "Using default recording directory";+ }, [isUsingManualPath]);++ // Derive status for collapsed summary+ const statusLabel = isRecording+ ? `Recording ${recordingProgress.toFixed(0)}%`+ : isLoading+ ? "Processing..."+ : "Idle";++ const statusColor = isRecording+ ? theme.palette.error.main+ : isLoading+ ? theme.palette.warning.main+ : theme.palette.grey[600];++ // Primary control: compact start/stop recording toggle in the header+ const headerRecordButton = isRecording ? (+ <Tooltip title="Stop mocap recording">+ <IconButton+ size="small"+ onClick={(e: React.MouseEvent) => {+ e.stopPropagation();+ dispatchStopMocapRecording();+ }}+ disabled={isLoading}+ sx={{+ color: theme.palette.error.light,+ border: `1.5px solid ${theme.palette.error.light}`,+ borderRadius: 1,+ p: 0.5,+ "&:hover": {backgroundColor: "rgba(244,67,54,0.15)"},+ }}+ >+ <StopIcon fontSize="small" />+ </IconButton>+ </Tooltip>+ ) : (+ <Tooltip title={canStartRecording ? "Start mocap recording" : "Cannot record yet"}>+ <span>+ <IconButton+ size="small"+ onClick={(e: React.MouseEvent) => {+ e.stopPropagation();+ dispatchStartMocapRecording();+ }}+ disabled={!canStartRecording || isLoading}+ sx={{+ color: "inherit",+ border: "1.5px solid rgba(255,255,255,0.25)",+ borderRadius: 1,+ p: 0.5,+ "&:hover": {backgroundColor: "rgba(255,255,255,0.1)"},+ "&.Mui-disabled": {+ color: "rgba(255,255,255,0.3)",+ borderColor: "rgba(255,255,255,0.1)",+ },+ }}+ >+ <FiberManualRecordIcon fontSize="small" />+ </IconButton>+ </span>+ </Tooltip>+ );++ return (+ <CollapsibleSidebarSection+ icon={<DirectionsRunIcon sx={{color: "inherit"}} />}+ title="Motion Capture"+ summaryContent={+ <Chip+ label={statusLabel}+ size="small"+ sx={{+ height: 20,+ fontSize: 11,+ fontWeight: 600,+ backgroundColor: statusColor,+ color: theme.palette.getContrastText(statusColor),+ }}+ />+ }+ primaryControl={headerRecordButton}+ defaultExpanded={false}+ >+ <Box sx={{p: 2, bgcolor: "background.paper"}}>+ <Stack spacing={2}>+ {/* Error Display */}+ {displayError && (+ <Alert severity="error" onClose={handleClearError}>+ {displayError}+ </Alert>+ )}++ {/* Recording Controls */}+ <Stack direction="row" spacing={2}>+ <Button+ variant="contained"+ color="primary"+ startIcon={<PlayArrowIcon />}+ onClick={dispatchStartMocapRecording}+ disabled={!canStartRecording || isLoading}+ fullWidth+ >+ Start Mocap Recording+ </Button>+ {isRecording && (+ <Button+ variant="contained"+ color="error"+ startIcon={<StopIcon />}+ onClick={dispatchStopMocapRecording}+ disabled={isLoading}+ fullWidth+ >+ Stop Recording+ </Button>+ )}+ </Stack>++ {/* Recording Path Input */}+ <TextField+ label="Mocap Recording Path"+ value={mocapRecordingPath}+ onChange={handlePathInputChange}+ fullWidth+ size="small"+ helperText={pathHelperText}+ InputProps={{+ endAdornment: (+ <InputAdornment position="end">+ {isUsingManualPath && (+ <Tooltip title="Clear manual path (revert to default)">+ <IconButton+ onClick={handleClearManualPath}+ edge="end"+ size="small"+ >+ <ClearIcon fontSize="small" />+ </IconButton>+ </Tooltip>+ )}+ <Tooltip title="Select directory">+ <IconButton+ onClick={handleSelectDirectory}+ edge="end"+ disabled={!isElectron}+ >+ <FolderOpenIcon />+ </IconButton>+ </Tooltip>+ </InputAdornment>+ ),+ }}+ />++ {/* Directory Status Info */}+ {directoryInfo && (+ <Box+ sx={{+ p: 1.5,+ borderRadius: 1,+ border: `2px solid ${theme.palette.divider}`,+ }}+ >+ <Stack spacing={1}>+ <Box+ sx={{+ display: "flex",+ alignItems: "center",+ gap: 1,+ }}+ >+ <InfoIcon fontSize="small" color="info" />+ <Typography variant="caption" fontWeight="medium">+ Mocap Folder Status+ </Typography>+ </Box>++ <Box+ sx={{+ display: "flex",+ gap: 1,+ flexWrap: "wrap",+ }}+ >+ <Chip+ label={+ directoryInfo.exists+ ? "Directory exists"+ : "Directory will be created"+ }+ size="small"+ color={directoryInfo.exists ? "success" : "default"}+ icon={+ directoryInfo.exists ? (+ <CheckCircleIcon />+ ) : (+ <CloseIcon />+ )+ }+ variant={directoryInfo.exists ? "filled" : "outlined"}+ sx={+ !directoryInfo.exists+ ? {+ borderColor: theme.palette.grey[400],+ "& .MuiChip-icon": {+ color: theme.palette.grey[600],+ },+ }+ : {}+ }+ />+ <Chip+ label="Has videos"+ size="small"+ color={directoryInfo.hasVideos ? "success" : "default"}+ icon={+ directoryInfo.hasVideos ? (+ <CheckCircleIcon />+ ) : (+ <CloseIcon />+ )+ }+ variant={directoryInfo.hasVideos ? "filled" : "outlined"}+ sx={+ !directoryInfo.hasVideos+ ? {+ borderColor: theme.palette.grey[400],+ "& .MuiChip-icon": {+ color: theme.palette.grey[600],+ },+ }+ : {}+ }+ />+ <Chip+ label="Has synchronized_videos"+ size="small"+ color={+ directoryInfo.hasSynchronizedVideos+ ? "success"+ : "default"+ }+ icon={+ directoryInfo.hasSynchronizedVideos ? (+ <CheckCircleIcon />+ ) : (+ <CloseIcon />+ )+ }+ variant={+ directoryInfo.hasSynchronizedVideos+ ? "filled"+ : "outlined"+ }+ sx={+ !directoryInfo.hasSynchronizedVideos+ ? {+ borderColor: theme.palette.grey[400],+ "& .MuiChip-icon": {+ color: theme.palette.grey[600],+ },+ }+ : {}+ }+ />+ <Chip+ label="Has calibration TOML"+ size="small"+ color={+ directoryInfo.cameraMocapTomlPath+ ? "success"+ : "default"+ }+ icon={+ directoryInfo.cameraMocapTomlPath ? (+ <CheckCircleIcon />+ ) : (+ <CloseIcon />+ )+ }+ variant={+ directoryInfo.cameraMocapTomlPath+ ? "filled"+ : "outlined"+ }+ sx={+ !directoryInfo.cameraMocapTomlPath+ ? {+ borderColor: theme.palette.grey[400],+ "& .MuiChip-icon": {+ color: theme.palette.grey[600],+ },+ }+ : {}+ }+ />+ </Box>++ {directoryInfo.cameraMocapTomlPath && (+ <Box sx={{mt: 1}}>+ <Typography variant="caption" color="text.secondary">+ Found calibration file:+ </Typography>+ <Typography+ variant="caption"+ sx={{+ fontFamily: "monospace",+ display: "block",+ color: "success.main",+ wordBreak: "break-all",+ }}+ >+ {directoryInfo.cameraMocapTomlPath}+ </Typography>+ </Box>+ )}+ </Stack>+ </Box>+ )}++ {/* Recording Progress */}+ {isRecording && (+ <Box sx={{width: "100%"}}>+ <Typography+ variant="caption"+ color="text.secondary"+ gutterBottom+ >+ Recording in Progress: {recordingProgress.toFixed(0)}%+ </Typography>+ <Box+ sx={{+ width: "100%",+ height: 8,+ bgcolor: "grey.300",+ borderRadius: 1,+ overflow: "hidden",+ }}+ >+ <Box+ sx={{+ width: `${recordingProgress}%`,+ height: "100%",+ bgcolor: theme.palette.primary.main,+ transition: "width 0.3s",+ }}+ />+ </Box>+ </Box>+ )}++ {/* MediaPipe Detector Config */}+ <MediapipeConfigPanel />++ {/* Skeleton Filter Config */}+ <SkeletonFilterConfigPanel />++ {/* Process Recording Button */}+ <Button+ variant="contained"+ color="secondary"+ onClick={dispatchProcessMocapRecording}+ disabled={!canProcessMocapRecording || isLoading}+ fullWidth+ >+ Process Selected Recording+ </Button>+ </Stack>+ </Box>+ </CollapsibleSidebarSection>+ );+};diff --git a/freemocap-ui/src/components/mocap-control-panel/SkeletonFilterConfigPanel.tsx b/freemocap-ui/src/components/mocap-control-panel/SkeletonFilterConfigPanel.tsxnew file mode 100644index 00000000..776cc1ff--- /dev/null+++ b/freemocap-ui/src/components/mocap-control-panel/SkeletonFilterConfigPanel.tsx@@ -0,0 +1,215 @@+import React, {useCallback} from "react";+import {+ Box,+ Button,+ Divider,+ Slider,+ Stack,+ TextField,+ Tooltip,+ Typography,+ useTheme,+} from "@mui/material";+import {useMocap} from "@/hooks/useMocap";+import {DEFAULT_REALTIME_FILTER_CONFIG} from "@/store/slices/mocap";++/** Warm amber for section headings — visible on dark backgrounds. */+const SECTION_COLOR = "#ffb74d";++/** Shared slider sx that matches the camera config panel style. */+const useSliderSx = () => {+ const theme = useTheme();+ return {+ color: theme.palette.primary.light,+ "& .MuiSlider-thumb": {+ "&:hover, &.Mui-focusVisible": {+ boxShadow: `0px 0px 0px 8px ${theme.palette.primary.light}33`,+ },+ },+ } as const;+};++export const SkeletonFilterConfigPanel: React.FC = () => {+ const theme = useTheme();+ const sliderSx = useSliderSx();+ const {skeletonFilterConfig, updateSkeletonFilterConfig, replaceSkeletonFilterConfig, isLoading} = useMocap();++ const handleResetDefaults = useCallback(() => {+ replaceSkeletonFilterConfig({...DEFAULT_REALTIME_FILTER_CONFIG});+ }, [replaceSkeletonFilterConfig]);++ return (+ <Stack spacing={1}>+ <Stack direction="row" justifyContent="space-between" alignItems="center">+ <Typography variant="subtitle2" sx={{color: theme.palette.text.secondary, fontWeight: 600}}>+ Skeleton Filter+ </Typography>+ <Button+ size="small"+ variant="text"+ onClick={handleResetDefaults}+ disabled={isLoading}+ sx={{fontSize: 11, textTransform: "none"}}+ >+ Reset Defaults+ </Button>+ </Stack>++ {/* === Point Gate === */}+ <Typography variant="caption" sx={{color: SECTION_COLOR, fontWeight: 600}}>+ Point Gate+ </Typography>++ <Tooltip title="Reject triangulated points whose mean reprojection error exceeds this. Higher = keep more (noisier) points." placement="right" arrow>+ <Box>+ <Typography variant="caption" color="text.secondary">+ Max Reproj Error: {skeletonFilterConfig.max_reprojection_error_px.toFixed(0)} px+ </Typography>+ <Slider+ value={skeletonFilterConfig.max_reprojection_error_px}+ onChange={(_, v) => updateSkeletonFilterConfig({max_reprojection_error_px: v as number})}+ min={5} max={200} step={1} size="small" disabled={isLoading}+ sx={sliderSx}+ />+ </Box>+ </Tooltip>++ <Tooltip title="Reject points moving faster than this between frames. Catches teleportation spikes. Human limbs rarely exceed ~15 m/s." placement="right" arrow>+ <Box>+ <Typography variant="caption" color="text.secondary">+ Max Velocity: {skeletonFilterConfig.max_velocity_m_per_s.toFixed(0)} m/s+ </Typography>+ <Slider+ value={skeletonFilterConfig.max_velocity_m_per_s}+ onChange={(_, v) => updateSkeletonFilterConfig({max_velocity_m_per_s: v as number})}+ min={5} max={200} step={1} size="small" disabled={isLoading}+ sx={sliderSx}+ />+ </Box>+ </Tooltip>++ <Tooltip title="After this many consecutive velocity rejections, accept unconditionally to prevent permanent lockout." placement="right" arrow>+ <Box>+ <Typography variant="caption" color="text.secondary">+ Max Rejected Streak: {skeletonFilterConfig.max_rejected_streak}+ </Typography>+ <Slider+ value={skeletonFilterConfig.max_rejected_streak}+ onChange={(_, v) => updateSkeletonFilterConfig({max_rejected_streak: v as number})}+ min={1} max={30} step={1} size="small" disabled={isLoading}+ sx={sliderSx}+ />+ </Box>+ </Tooltip>++ <Divider />++ {/* === One Euro Filter === */}+ <Typography variant="caption" sx={{color: SECTION_COLOR, fontWeight: 600}}>+ One Euro Filter+ </Typography>++ <Tooltip title="Minimum cutoff frequency (Hz). Lower = heavier smoothing (less jitter, more lag). Higher = more responsive." placement="right" arrow>+ <Box>+ <Typography variant="caption" color="text.secondary">+ Min Cutoff: {skeletonFilterConfig.min_cutoff.toFixed(4)}+ </Typography>+ <Slider+ value={skeletonFilterConfig.min_cutoff}+ onChange={(_, v) => updateSkeletonFilterConfig({min_cutoff: v as number})}+ min={0.0001} max={0.1} step={0.0005} size="small" disabled={isLoading}+ sx={sliderSx}+ />+ </Box>+ </Tooltip>++ <Tooltip title="Speed coefficient. Higher = less lag during fast motion but more jitter. Zero = constant smoothing regardless of speed." placement="right" arrow>+ <Box>+ <Typography variant="caption" color="text.secondary">+ Beta: {skeletonFilterConfig.beta.toFixed(2)}+ </Typography>+ <Slider+ value={skeletonFilterConfig.beta}+ onChange={(_, v) => updateSkeletonFilterConfig({beta: v as number})}+ min={0} max={5} step={0.05} size="small" disabled={isLoading}+ sx={sliderSx}+ />+ </Box>+ </Tooltip>++ <Tooltip title="Cutoff frequency for the speed estimator. Controls how quickly the filter reacts to speed changes. Usually fine at 1.0." placement="right" arrow>+ <Box>+ <Typography variant="caption" color="text.secondary">+ D Cutoff: {skeletonFilterConfig.d_cutoff.toFixed(2)}+ </Typography>+ <Slider+ value={skeletonFilterConfig.d_cutoff}+ onChange={(_, v) => updateSkeletonFilterConfig({d_cutoff: v as number})}+ min={0.1} max={5} step={0.1} size="small" disabled={isLoading}+ sx={sliderSx}+ />+ </Box>+ </Tooltip>++ <Divider />++ {/* === FABRIK === */}+ <Typography variant="caption" sx={{color: SECTION_COLOR, fontWeight: 600}}>+ FABRIK+ </Typography>++ <Tooltip title="Max solver iterations per frame for bone length constraint enforcement. 10–30 is usually plenty." placement="right" arrow>+ <Box>+ <Typography variant="caption" color="text.secondary">+ Max Iterations: {skeletonFilterConfig.fabrik_max_iterations}+ </Typography>+ <Slider+ value={skeletonFilterConfig.fabrik_max_iterations}+ onChange={(_, v) => updateSkeletonFilterConfig({fabrik_max_iterations: v as number})}+ min={1} max={100} step={1} size="small" disabled={isLoading}+ sx={sliderSx}+ />+ </Box>+ </Tooltip>++ <Divider />++ {/* === Body Model === */}+ <Typography variant="caption" sx={{color: SECTION_COLOR, fontWeight: 600}}>+ Body Model+ </Typography>++ <Tooltip title="Subject's approximate height. Scales the anthropometric bone length prior. Doesn't need to be exact." placement="right" arrow>+ <TextField+ label="Height (m)"+ type="number"+ size="small"+ value={skeletonFilterConfig.height_meters}+ onChange={(e) => {+ const val = parseFloat(e.target.value);+ if (!isNaN(val) && val > 0) {+ updateSkeletonFilterConfig({height_meters: val});+ }+ }}+ inputProps={{step: 0.01, min: 0.5, max: 3.0}}+ disabled={isLoading}+ fullWidth+ />+ </Tooltip>++ <Tooltip title="Expected measurement noise (meters). Higher = trust raw positions less, rely more on prior estimates." placement="right" arrow>+ <Box>+ <Typography variant="caption" color="text.secondary">+ Noise Sigma: {skeletonFilterConfig.noise_sigma.toFixed(4)} m+ </Typography>+ <Slider+ value={skeletonFilterConfig.noise_sigma}+ onChange={(_, v) => updateSkeletonFilterConfig({noise_sigma: v as number})}+ min={0.001} max={0.05} step={0.001} size="small" disabled={isLoading}+ sx={sliderSx}+ />+ </Box>+ </Tooltip>+ </Stack>+ );+};diff --git a/freemocap-ui/src/components/mocap-task-panel/MocapTaskTreeItem.tsx b/freemocap-ui/src/components/mocap-task-panel/MocapTaskTreeItem.tsxdeleted file mode 100644index d373c737..00000000--- a/freemocap-ui/src/components/mocap-task-panel/MocapTaskTreeItem.tsx+++ /dev/null@@ -1,352 +0,0 @@-// components/MocapTaskTreeItem.tsx-import React, {useCallback, useMemo, useState} from 'react';-import {- Alert,- Box,- Button,- Chip,- IconButton,- InputAdornment,- Stack,- TextField,- Tooltip,- Typography,- useTheme,-} from '@mui/material';-import {TreeItem} from '@mui/x-tree-view/TreeItem';-import DirectionsRunIcon from '@mui/icons-material/DirectionsRun';-import PlayArrowIcon from '@mui/icons-material/PlayArrow';-import StopIcon from '@mui/icons-material/Stop';-import FolderOpenIcon from '@mui/icons-material/FolderOpen';-import ClearIcon from '@mui/icons-material/Clear';-import CheckCircleIcon from '@mui/icons-material/CheckCircle';-import InfoIcon from '@mui/icons-material/Info';-import CloseIcon from '@mui/icons-material/Close';-import {useMocap} from '@/hooks/useMocap';-import {useElectronIPC} from '@/services';-import ExpandMoreIcon from "@mui/icons-material/ExpandMore";-import ChevronRightIcon from "@mui/icons-material/ChevronRight";-import {SimpleTreeView} from "@mui/x-tree-view";---export const MocapTaskTreeItem: React.FC = () => {- const theme = useTheme();- const [localError, setLocalError] = useState<string | null>(null);- const [expandedItems, setExpandedItems] = useState<string[]>([- 'pipeline-main',- 'calibration-intrinsic',- 'calibration-extrinsic',- 'mocap-task'- ]);- const handleExpandedItemsChange = (- event: React.SyntheticEvent,- itemIds: string[]- ): void => {- setExpandedItems(itemIds);- };- const { api, isElectron } = useElectronIPC();-- const {- config,- error,- isLoading,- isRecording,- recordingProgress,- canStartRecording,- canProcessMocapRecording,- mocapRecordingPath,- directoryInfo,- isUsingManualPath,- updateMocapConfig,- dispatchStopMocapRecording,- dispatchStartMocapRecording,- setManualRecordingPath,- clearManualRecordingPath,- dispatchProcessMocapRecording,- clearError,- } = useMocap();----- const handleClearError = useCallback((): void => {- clearError();- setLocalError(null);- }, [clearError]);---- const handleSelectDirectory = async (): Promise<void> => {- if (!isElectron || !api) {- console.warn('Electron API not available');- return;- }-- try {- const result: string | null = await api.fileSystem.selectDirectory.mutate();- if (result) {- await setManualRecordingPath(result);- }- } catch (error) {- console.error('Failed to select directory:', error);- setLocalError('Failed to select directory');- }- };-- const handlePathInputChange = async (e: React.ChangeEvent<HTMLInputElement>): Promise<void> => {- const newPath: string = e.target.value;-- // Handle tilde expansion for home directory- if (newPath.includes('~') && isElectron && api) {- try {- const home: string = await api.fileSystem.getHomeDirectory.query();- const expanded: string = newPath.replace(/^~([\/\\])?/, home ? `${home}$1` : '');- await setManualRecordingPath(expanded);- } catch (error) {- console.error('Failed to expand home directory:', error);- await setManualRecordingPath(newPath);- }- } else {- await setManualRecordingPath(newPath);- }- };-- const handleClearManualPath = useCallback((): void => {- clearManualRecordingPath();- }, [clearManualRecordingPath]);-- const displayError = error || localError || directoryInfo?.errorMessage;-- // Helper text for the path input- const pathHelperText = useMemo(() => {- if (isUsingManualPath) {- return 'Using custom path';- }- return 'Using default recording directory';- }, [isUsingManualPath]);-- return (- <SimpleTreeView- expandedItems={expandedItems}- onExpandedItemsChange={handleExpandedItemsChange}- slots={{- collapseIcon: ExpandMoreIcon,- expandIcon: ChevronRightIcon,- }}- sx={{ flexGrow: 1 }}- >- <TreeItem- itemId="mocap-task"- label={- <Box sx={{ display: 'flex', alignItems: 'center', py: 1, pr: 1 }}>- <DirectionsRunIcon sx={{ mr: 1, color: theme.palette.secondary.main }} />- <Typography variant="subtitle1" sx={{ flexGrow: 1 }}>- Motion Capture- </Typography>- </Box>- }- >- <Box sx={{ p: 2, bgcolor: 'background.paper' }}>- <Stack spacing={2}>- {/* Error Display */}- {displayError && (- <Alert severity="error" onClose={handleClearError}>- {displayError}- </Alert>- )}-- {/* Mocap Recording Path Input */}- <Box>-- {/* Recording Controls */}- <Stack direction="row" spacing={2} sx={{ mb: 2 }}>- <Button- variant="contained"- color="primary"- startIcon={<PlayArrowIcon />}- onClick={dispatchStartMocapRecording}- disabled={!canStartRecording || isLoading}- fullWidth- >- Start Mocap Recording- </Button>- {isRecording && (- <Button- variant="contained"- color="error"- startIcon={<StopIcon />}- onClick={dispatchStopMocapRecording}- disabled={isLoading}- fullWidth- >- Stop Recording- </Button>- )}- </Stack>- <TextField- label="Mocap Recording Path"- value={mocapRecordingPath}- onChange={handlePathInputChange}- fullWidth- size="small"- helperText={pathHelperText}- InputProps={{- endAdornment: (- <InputAdornment position="end">- {isUsingManualPath && (- <Tooltip title="Clear manual path (revert to default)">- <IconButton- onClick={handleClearManualPath}- edge="end"- size="small"- >- <ClearIcon fontSize="small" />- </IconButton>- </Tooltip>- )}- <Tooltip title="Select directory">- <IconButton- onClick={handleSelectDirectory}- edge="end"- disabled={!isElectron}- >- <FolderOpenIcon />- </IconButton>- </Tooltip>- </InputAdornment>- ),- }}- />- </Box>-- {/* Directory Status Info */}- {directoryInfo && (- <Box sx={{- p: 1.5,- borderRadius: 1,- border: `2px solid ${theme.palette.divider}`- }}>- <Stack spacing={1}>- <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>- <InfoIcon fontSize="small" color="info" />- <Typography variant="caption" fontWeight="medium">- Mocap Folder Status- </Typography>- </Box>-- <Box sx={{ display: 'flex', gap: 1, flexWrap: 'wrap' }}>- <Chip- label={directoryInfo.exists ? "Directory exists" : "Directory will be created"}- size="small"- color={directoryInfo.exists ? "success" : "default"}- icon={directoryInfo.exists ? <CheckCircleIcon /> : <CloseIcon />}- variant={directoryInfo.exists ? "filled" : "outlined"}- sx={!directoryInfo.exists ? {- borderColor: theme.palette.grey[400],- '& .MuiChip-icon': { color: theme.palette.grey[600] }- } : {}}- />-- <Chip- label="Has videos"- size="small"- color={directoryInfo.hasVideos ? "success" : "default"}- icon={directoryInfo.hasVideos ? <CheckCircleIcon /> : <CloseIcon />}- variant={directoryInfo.hasVideos ? "filled" : "outlined"}- sx={!directoryInfo.hasVideos ? {- borderColor: theme.palette.grey[400],- '& .MuiChip-icon': { color: theme.palette.grey[600] }- } : {}}- />-- <Chip- label="Has synchronized_videos"- size="small"- color={directoryInfo.hasSynchronizedVideos ? "success" : "default"}- icon={directoryInfo.hasSynchronizedVideos ? <CheckCircleIcon /> : <CloseIcon />}- variant={directoryInfo.hasSynchronizedVideos ? "filled" : "outlined"}- sx={!directoryInfo.hasSynchronizedVideos ? {- borderColor: theme.palette.grey[400],- '& .MuiChip-icon': { color: theme.palette.grey[600] }- } : {}}- />-- <Chip- label="Has calibration TOML"- size="small"- color={directoryInfo.cameraMocapTomlPath ? "success" : "default"}- icon={directoryInfo.cameraMocapTomlPath ? <CheckCircleIcon /> : <CloseIcon />}- variant={directoryInfo.cameraMocapTomlPath ? "filled" : "outlined"}- sx={!directoryInfo.cameraMocapTomlPath ? {- borderColor: theme.palette.grey[400],- '& .MuiChip-icon': { color: theme.palette.grey[600] }- } : {}}- />- </Box>-- {directoryInfo.cameraMocapTomlPath && (- <Box sx={{ mt: 1 }}>- <Typography variant="caption" color="text.secondary">- Found calibration file:- </Typography>- <Typography- variant="caption"- sx={{- fontFamily: 'monospace',- display: 'block',- color: 'success.main',- wordBreak: 'break-all'- }}- >- {directoryInfo.cameraMocapTomlPath}- </Typography>- </Box>- )}- </Stack>- </Box>- )}--- {/* Recording Progress */}- {isRecording && (- <Box sx={{ width: '100%' }}>- <Typography variant="caption" color="text.secondary" gutterBottom>- Recording in Progress: {recordingProgress.toFixed(0)}%- </Typography>- <Box- sx={{- width: '100%',- height: 8,- bgcolor: 'grey.300',- borderRadius: 1,- overflow: 'hidden',- }}- >- <Box- sx={{- width: `${recordingProgress}%`,- height: '100%',- bgcolor: theme.palette.primary.main,- transition: 'width 0.3s',- }}- />- </Box>- </Box>- )}-- {/* Process Recording Button */}- <Button- variant="contained"- color="secondary"- onClick={dispatchProcessMocapRecording}- // disabled={!canProcessMocapRecording || isLoading}- fullWidth- >- Process Selected Recording- </Button>- </Stack>- </Box>- </TreeItem>- </SimpleTreeView>- );-};diff --git a/freemocap-ui/src/components/processing-pipeline-panel/PipelineConnectionToggle.tsx b/freemocap-ui/src/components/processing-pipeline-panel/PipelineConnectionToggle.tsxnew file mode 100644index 00000000..a53a1d8c--- /dev/null+++ b/freemocap-ui/src/components/processing-pipeline-panel/PipelineConnectionToggle.tsx@@ -0,0 +1,80 @@+import React from "react";+import {CircularProgress, IconButton, Tooltip, useTheme} from "@mui/material";+import PowerSettingsNewIcon from "@mui/icons-material/PowerSettingsNew";+import {useAppDispatch, useAppSelector} from "@/store/hooks";+import {+ closePipeline,+ connectRealtimePipeline,+ selectCanConnectPipeline,+ selectCanDisconnectPipeline,+ selectIsPipelineConnected,+ selectIsPipelineLoading,+} from "@/store/slices/pipeline";++export const PipelineConnectionToggle: React.FC = () => {+ const theme = useTheme();+ const dispatch = useAppDispatch();++ const isConnected = useAppSelector(selectIsPipelineConnected);+ const isLoading = useAppSelector(selectIsPipelineLoading);+ const canConnect = useAppSelector(selectCanConnectPipeline);+ const canDisconnect = useAppSelector(selectCanDisconnectPipeline);++ const isClickable = canConnect || canDisconnect;++ const handleToggle = async (e: React.MouseEvent): Promise<void> => {+ e.stopPropagation();+ if (isLoading) return;++ if (isConnected) {+ await dispatch(closePipeline());+ } else {+ await dispatch(connectRealtimePipeline(undefined));+ }+ };++ const tooltipText = isConnected+ ? "Disconnect pipeline"+ : canConnect+ ? "Connect pipeline"+ : "Select cameras first";++ return (+ <Tooltip title={tooltipText}>+ <span>+ <IconButton+ size="small"+ onClick={handleToggle}+ disabled={!isClickable || isLoading}+ sx={{+ color: "inherit",+ border: "1.5px solid",+ borderColor: isConnected+ ? theme.palette.success.light+ : "rgba(255,255,255,0.25)",+ borderRadius: 1,+ p: 0.5,+ backgroundColor: isConnected+ ? "rgba(76, 175, 80, 0.2)"+ : "transparent",+ "&:hover": {+ backgroundColor: isConnected+ ? "rgba(76, 175, 80, 0.3)"+ : "rgba(255,255,255,0.1)",+ },+ "&.Mui-disabled": {+ color: "rgba(255,255,255,0.3)",+ borderColor: "rgba(255,255,255,0.1)",+ },+ }}+ >+ {isLoading ? (+ <CircularProgress size={18} sx={{color: "inherit"}} />+ ) : (+ <PowerSettingsNewIcon fontSize="small" />+ )}+ </IconButton>+ </span>+ </Tooltip>+ );+};diff --git a/freemocap-ui/src/components/processing-pipeline-panel/PipelineSummary.tsx b/freemocap-ui/src/components/processing-pipeline-panel/PipelineSummary.tsxnew file mode 100644index 00000000..05619890--- /dev/null+++ b/freemocap-ui/src/components/processing-pipeline-panel/PipelineSummary.tsx@@ -0,0 +1,56 @@+import React from "react";+import {Chip, Typography, useTheme} from "@mui/material";+import {useAppSelector} from "@/store/hooks";+import {+ selectIsPipelineConnected,+ selectPipelineError,+ selectPipelineId,+} from "@/store/slices/pipeline";++export const PipelineSummary: React.FC = () => {+ const theme = useTheme();++ const isConnected = useAppSelector(selectIsPipelineConnected);+ const pipelineId = useAppSelector(selectPipelineId);+ const error = useAppSelector(selectPipelineError);++ if (error) {+ return (+ <Typography+ variant="caption"+ sx={{+ color: theme.palette.error.light,+ fontWeight: 500,+ whiteSpace: "nowrap",+ overflow: "hidden",+ textOverflow: "ellipsis",+ }}+ >+ Error+ </Typography>+ );+ }++ const statusColor = isConnected+ ? theme.palette.success.main+ : theme.palette.grey[600];++ return (+ <Chip+ label={isConnected ? `Active (${pipelineId})` : "Inactive"}+ size="small"+ sx={{+ height: 20,+ fontSize: 11,+ fontWeight: 600,+ backgroundColor: statusColor,+ color: theme.palette.getContrastText(statusColor),+ maxWidth: 160,+ "& .MuiChip-label": {+ overflow: "hidden",+ textOverflow: "ellipsis",+ },+ }}+ />+ );+};diff --git a/freemocap-ui/src/components/processing-pipeline-panel/ProcessingPipelinePanel.tsx b/freemocap-ui/src/components/processing-pipeline-panel/ProcessingPipelinePanel.tsxindex bb91a72b..3a7ac632 100644--- a/freemocap-ui/src/components/processing-pipeline-panel/ProcessingPipelinePanel.tsx+++ b/freemocap-ui/src/components/processing-pipeline-panel/ProcessingPipelinePanel.tsx@@ -1,69 +1,114 @@-import React, {useState} from "react";-import {Box, Typography, useTheme} from "@mui/material";-import {SimpleTreeView} from "@mui/x-tree-view/SimpleTreeView";-import {TreeItem} from "@mui/x-tree-view/TreeItem";-import ExpandMoreIcon from "@mui/icons-material/ExpandMore";-import ChevronRightIcon from "@mui/icons-material/ChevronRight";-import LanIcon from '@mui/icons-material/Lan';-import PipelineConnectionStatus from "@/components/processing-pipeline-panel/PipelineConnectionStatus";-import {RecordingInfoPanel} from "@/components/recording-info-panel/RecordingInfoPanel";+import React from "react";+import {Box, FormControlLabel, Stack, Switch, Typography, useTheme} from "@mui/material";+import LanIcon from "@mui/icons-material/Lan";+import {CollapsibleSidebarSection} from "@/components/common/CollapsibleSidebarSection";+import {PipelineConnectionToggle} from "@/components/processing-pipeline-panel/PipelineConnectionToggle";+import {PipelineSummary} from "@/components/processing-pipeline-panel/PipelineSummary";+import {useAppSelector} from "@/store/hooks";+import {selectBackendPipeline} from "@/store/slices/settings";+import {useServer} from "@/hooks/useServer";+import {MediapipeConfigPanel} from "@/components/mocap-control-panel/MediapipeConfigPanel";+import {SkeletonFilterConfigPanel} from "@/components/mocap-control-panel/SkeletonFilterConfigPanel";export const ProcessingPipelinePanel: React.FC = () => {const theme = useTheme();- const [expandedItems, setExpandedItems] = useState<string[]>([- 'pipeline-main',- 'calibration-intrinsic',- 'calibration-extrinsic',- 'mocap-task'- ]);+ const {send, isConnected} = useServer();+ const backendPipeline = useAppSelector(selectBackendPipeline);- const handleExpandedItemsChange = (- event: React.SyntheticEvent,- itemIds: string[]- ): void => {- setExpandedItems(itemIds);+ const pipelineConfig = backendPipeline?.config;+ const isPipelineConnected = backendPipeline?.is_connected ?? false;+ const canToggle = isConnected && isPipelineConnected;++ const handleToggleCalibrationDetection = (_: React.ChangeEvent, checked: boolean) => {+ send({+ message_type: "settings/patch",+ patch: {+ pipeline: {+ config: {+ calibration_detection_enabled: checked,+ },+ },+ },+ });+ };++ const handleToggleMocapDetection = (_: React.ChangeEvent, checked: boolean) => {+ send({+ message_type: "settings/patch",+ patch: {+ pipeline: {+ config: {+ mocap_detection_enabled: checked,+ },+ },+ },+ });};return (- <Box- sx={{- color: "text.primary",- backgroundColor: theme.palette.primary.main,- borderRadius: 1,- mb: 2,- }}+ <CollapsibleSidebarSection+ icon={<LanIcon sx={{transform: "scaleY(-1.05)", color: "inherit"}} />}+ title="Realtime Pipeline"+ summaryContent={<PipelineSummary />}+ primaryControl={<PipelineConnectionToggle />}+ defaultExpanded={false}>- <SimpleTreeView- expandedItems={expandedItems}- onExpandedItemsChange={handleExpandedItemsChange}- slots={{- collapseIcon: ExpandMoreIcon,- expandIcon: ChevronRightIcon,- }}- sx={{ flexGrow: 1 }}- >- <TreeItem- itemId="pipeline-main"- label={- <Box- sx={{- display: "flex",- alignItems: "center",- width: "100%",- py: 1,- }}- >- <LanIcon sx={{ transform: 'scaleY(-1.05) scaleX(1)' }} />-- <Typography sx={{ pl: 1, flexGrow: 1 }} variant="h6" component="div">- Realtime Pipeline+ <Box sx={{p: 2}}>+ <Stack spacing={2}>+ {/* Detection toggles — always visible, disabled when pipeline not connected */}+ <Typography+ variant="subtitle2"+ sx={{color: theme.palette.text.secondary, fontWeight: 600}}+ >+ Detection Stages+ </Typography>+ {!isPipelineConnected && (+ <Typography variant="caption" color="text.secondary" sx={{fontStyle: "italic"}}>+ Connect a pipeline to enable detection toggles.+ </Typography>+ )}+ <FormControlLabel+ control={+ <Switch+ size="small"+ checked={pipelineConfig?.calibration_detection_enabled ?? true}+ onChange={handleToggleCalibrationDetection}+ disabled={!canToggle}+ />+ }+ label={+ <Typography variant="body2">+ Charuco Detection (Calibration)</Typography>- <PipelineConnectionStatus />- </Box>- }- >- </TreeItem>- </SimpleTreeView>- </Box>+ }+ />+ <FormControlLabel+ control={+ <Switch+ size="small"+ checked={pipelineConfig?.mocap_detection_enabled ?? true}+ onChange={handleToggleMocapDetection}+ disabled={!canToggle}+ />+ }+ label={+ <Typography variant="body2">+ MediaPipe Detection (MoCap)+ </Typography>+ }+ />++ {/* MediaPipe config — always visible */}+ <Box sx={{mt: 1, pl: 1, borderLeft: `2px solid ${theme.palette.divider}`}}>+ <MediapipeConfigPanel />+ </Box>++ {/* Skeleton filter config — always visible */}+ <Box sx={{mt: 1, pl: 1, borderLeft: `2px solid ${theme.palette.divider}`}}>+ <SkeletonFilterConfigPanel />+ </Box>+ </Stack>+ </Box>+ </CollapsibleSidebarSection>);-};+};\ No newline at end of filediff --git a/freemocap-ui/src/components/settings-editor/SettingsEditor.tsx b/freemocap-ui/src/components/settings-editor/SettingsEditor.tsxnew file mode 100644index 00000000..16d67b9a--- /dev/null+++ b/freemocap-ui/src/components/settings-editor/SettingsEditor.tsx@@ -0,0 +1,540 @@+import React, { useState, useCallback, useRef, useMemo, useEffect } from 'react';+import {+ Box,+ Button,+ ButtonGroup,+ Alert,+ Snackbar,+ Tooltip,+ Divider,+ CircularProgress,+} from '@mui/material';+import { useTheme } from '@mui/material/styles';+import Editor, { OnMount } from '@monaco-editor/react';+import UploadFileIcon from '@mui/icons-material/UploadFile';+import DownloadIcon from '@mui/icons-material/Download';+import CheckIcon from '@mui/icons-material/Check';+import RestoreIcon from '@mui/icons-material/Restore';+import ContentCopyIcon from '@mui/icons-material/ContentCopy';+import {+ useAppDispatch,+ useAppSelector,+ themeModeSet,+ recordingDirectoryChanged,+ configUpdated,+ selectServerSettings,+} from '@/store';+import {+ mocapDetectorConfigReplaced,+ skeletonFilterConfigReplaced,+ updateMocapConfigOnServer,+} from '@/store/slices/mocap';+import {calibrationConfigUpdated, updateCalibrationConfigOnServer } from '@/store/slices/calibration';+import { ThemeMode } from '@/store/slices/theme/theme-types';+import { useServer } from '@/hooks/useServer';+import {+ serialize,+ deserialize,+ convertFormat,+ SerializationFormat,+ FORMAT_EXTENSIONS,+ FORMAT_MIME_TYPES,+ FORMAT_MONACO_LANGUAGES,+} from './format-converters';++// ── Aggregated settings shape (config-only, no runtime state) ──++interface AggregatedSettings {+ appearance: {+ mode: string;+ };+ recording: {+ recording_directory: string;+ use_delay_start: boolean;+ delay_seconds: number;+ use_timestamp: boolean;+ use_increment: boolean;+ current_increment: number;+ base_name: string;+ recording_tag: string;+ create_subfolder: boolean;+ custom_subfolder_name: string;+ };+ calibration: {+ live_track_charuco: boolean;+ charuco_board_x_squares: number;+ charuco_board_y_squares: number;+ charuco_square_length: number;+ min_shared_views_per_camera: number;+ auto_stop_on_min_view_count: boolean;+ solver_method: string;+ use_groundplane: boolean;+ };+ mocap: {+ detector: Record<string, unknown>;+ skeleton_filter: Record<string, unknown>;+ };+ // vmc: {+ // enabled: boolean;+ // host: string;+ // port: number;+ // };+}++// ── Hook: gather current settings into a flat config object ──++function useAggregatedSettings(): AggregatedSettings {+ const themeMode = useAppSelector(state => state.theme.mode);+ const recording = useAppSelector(state => state.recording);+ const calibration = useAppSelector(state => state.calibration.config);+ const mocap = useAppSelector(state => state.mocap.config);+ const serverSettings = useAppSelector(selectServerSettings);++ return useMemo((): AggregatedSettings => ({+ appearance: {+ mode: themeMode,+ },+ recording: {+ recording_directory: recording.recordingDirectory,+ use_delay_start: recording.config.useDelayStart,+ delay_seconds: recording.config.delaySeconds,+ use_timestamp: recording.config.useTimestamp,+ use_increment: recording.config.useIncrement,+ current_increment: recording.config.currentIncrement,+ base_name: recording.config.baseName,+ recording_tag: recording.config.recordingTag,+ create_subfolder: recording.config.createSubfolder,+ custom_subfolder_name: recording.config.customSubfolderName,+ },+ calibration: {+ live_track_charuco: calibration.liveTrackCharuco,+ charuco_board_x_squares: calibration.charucoBoardXSquares,+ charuco_board_y_squares: calibration.charucoBoardYSquares,+ charuco_square_length: calibration.charucoSquareLength,+ min_shared_views_per_camera: calibration.minSharedViewsPerCamera,+ auto_stop_on_min_view_count: calibration.autoStopOnMinViewCount,+ solver_method: calibration.solverMethod,+ use_groundplane: calibration.useGroundplane,+ },+ mocap: {+ detector: mocap.detector as unknown as Record<string, unknown>,+ skeleton_filter: mocap.skeleton_filter as unknown as Record<string, unknown>,+ },+ // vmc: {+ // enabled: serverSettings?.vmc?.enabled ?? false,+ // host: serverSettings?.vmc?.host ?? '127.0.0.1',+ // port: serverSettings?.vmc?.port ?? 39539,+ // },+ }), [themeMode, recording, calibration, mocap, serverSettings]);+}++// ── Apply parsed settings back to the Redux stores ──++function useApplySettings() {+ const dispatch = useAppDispatch();+ const { send, isConnected } = useServer();++ return useCallback((parsed: Record<string, unknown>) => {+ const settings = parsed as unknown as Partial<AggregatedSettings>;++ // Appearance+ if (settings.appearance && typeof settings.appearance.mode === 'string') {+ const mode = settings.appearance.mode;+ if (mode === 'dark' || mode === 'light') {+ dispatch(themeModeSet(mode as ThemeMode));+ } else {+ throw new Error(`Invalid appearance.mode: "${mode}" (must be "dark" or "light")`);+ }+ }++ // Recording+ if (settings.recording) {+ const rec = settings.recording;+ if (typeof rec.recording_directory === 'string') {+ dispatch(recordingDirectoryChanged(rec.recording_directory));+ }+ dispatch(configUpdated({+ useDelayStart: rec.use_delay_start,+ delaySeconds: rec.delay_seconds,+ useTimestamp: rec.use_timestamp,+ useIncrement: rec.use_increment,+ currentIncrement: rec.current_increment,+ baseName: rec.base_name,+ recordingTag: rec.recording_tag,+ createSubfolder: rec.create_subfolder,+ customSubfolderName: rec.custom_subfolder_name,+ }));+ }++ // Calibration+ if (settings.calibration) {+ const cal = settings.calibration;+ dispatch(calibrationConfigUpdated({+ liveTrackCharuco: cal.live_track_charuco,+ charucoBoardXSquares: cal.charuco_board_x_squares,+ charucoBoardYSquares: cal.charuco_board_y_squares,+ charucoSquareLength: cal.charuco_square_length,+ minSharedViewsPerCamera: cal.min_shared_views_per_camera,+ autoStopOnMinViewCount: cal.auto_stop_on_min_view_count,+ solverMethod: cal.solver_method as 'anipose' | 'pyceres',+ useGroundplane: cal.use_groundplane,+ }));+ dispatch(updateCalibrationConfigOnServer());+ }++ // Mocap+ if (settings.mocap) {+ if (settings.mocap.detector) {+ dispatch(mocapDetectorConfigReplaced(settings.mocap.detector as any));+ }+ if (settings.mocap.skeleton_filter) {+ dispatch(skeletonFilterConfigReplaced(settings.mocap.skeleton_filter as any));+ }+ dispatch(updateMocapConfigOnServer());+ }++ // VMC (patched via WebSocket)+ if (settings.vmc && isConnected) {+ send({+ message_type: 'settings/patch',+ patch: {+ vmc: {+ enabled: settings.vmc.enabled,+ host: settings.vmc.host,+ port: settings.vmc.port,+ },+ },+ });+ }+ }, [dispatch, send, isConnected]);+}++// ── Format toggle button ──++function FormatButton({+ format,+ active,+ onClick,+}: {+ format: SerializationFormat;+ active: boolean;+ onClick: () => void;+}) {+ return (+ <Button+ size="small"+ variant={active ? 'contained' : 'outlined'}+ onClick={onClick}+ sx={{+ textTransform: 'uppercase',+ fontWeight: 700,+ fontSize: '0.7rem',+ minWidth: 56,+ letterSpacing: 0.8,+ }}+ >+ {format}+ </Button>+ );+}++// ── Main editor component ──++export const SettingsEditor: React.FC = () => {+ const theme = useTheme();+ const aggregated = useAggregatedSettings();+ const applySettings = useApplySettings();++ const [format, setFormat] = useState<SerializationFormat>('json');+ const [editorContent, setEditorContent] = useState<string>('');+ const [hasEdits, setHasEdits] = useState(false);+ const [error, setError] = useState<string | null>(null);+ const [snackbar, setSnackbar] = useState<{ message: string; severity: 'success' | 'error' } | null>(null);++ const editorRef = useRef<any>(null);+ const fileInputRef = useRef<HTMLInputElement>(null);++ // Serialize current settings whenever aggregated state or format changes (only if no pending edits)+ const serializedFromStore = useMemo(+ () => serialize(aggregated as unknown as Record<string, unknown>, format),+ [aggregated, format],+ );++ // Sync editor content from store when there are no pending edits+ useEffect(() => {+ if (!hasEdits) {+ setEditorContent(serializedFromStore);+ }+ }, [serializedFromStore, hasEdits]);++ // Initialize editor on first mount+ useEffect(() => {+ setEditorContent(serialize(aggregated as unknown as Record<string, unknown>, format));+ // Only run on mount+ // eslint-disable-next-line react-hooks/exhaustive-deps+ }, []);++ const handleEditorMount: OnMount = useCallback((editor) => {+ editorRef.current = editor;+ }, []);++ const handleEditorChange = useCallback((value: string | undefined) => {+ if (value === undefined) return;+ setEditorContent(value);+ setHasEdits(true);+ setError(null);+ }, []);++ // Format switching — convert current content to new format+ const handleFormatChange = useCallback((newFormat: SerializationFormat) => {+ if (newFormat === format) return;+ try {+ const converted = convertFormat(editorContent, format, newFormat);+ setEditorContent(converted);+ setFormat(newFormat);+ setError(null);+ } catch (err) {+ setError(`Cannot convert to ${newFormat.toUpperCase()}: ${err instanceof Error ? err.message : String(err)}`);+ }+ }, [editorContent, format]);++ // Reset editor to current store state+ const handleReset = useCallback(() => {+ const fresh = serialize(aggregated as unknown as Record<string, unknown>, format);+ setEditorContent(fresh);+ setHasEdits(false);+ setError(null);+ }, [aggregated, format]);++ // Apply edits to store+ const handleApply = useCallback(() => {+ try {+ const parsed = deserialize(editorContent, format);+ applySettings(parsed);+ setHasEdits(false);+ setError(null);+ setSnackbar({ message: 'Settings applied successfully', severity: 'success' });+ } catch (err) {+ const message = err instanceof Error ? err.message : String(err);+ setError(`Failed to apply: ${message}`);+ setSnackbar({ message: `Failed to apply settings: ${message}`, severity: 'error' });+ }+ }, [editorContent, format, applySettings]);++ // Copy to clipboard+ const handleCopy = useCallback(async () => {+ try {+ await navigator.clipboard.writeText(editorContent);+ setSnackbar({ message: 'Copied to clipboard', severity: 'success' });+ } catch {+ setSnackbar({ message: 'Failed to copy to clipboard', severity: 'error' });+ }+ }, [editorContent]);++ // Download as file+ const handleDownload = useCallback(() => {+ const blob = new Blob([editorContent], { type: FORMAT_MIME_TYPES[format] });+ const url = URL.createObjectURL(blob);+ const a = document.createElement('a');+ a.href = url;+ a.download = `freemocap-settings${FORMAT_EXTENSIONS[format]}`;+ a.click();+ URL.revokeObjectURL(url);+ }, [editorContent, format]);++ // Upload from file+ const handleUploadClick = useCallback(() => {+ fileInputRef.current?.click();+ }, []);++ const handleFileSelected = useCallback((e: React.ChangeEvent<HTMLInputElement>) => {+ const file = e.target.files?.[0];+ if (!file) return;++ // Detect format from file extension+ const ext = file.name.split('.').pop()?.toLowerCase();+ let detectedFormat: SerializationFormat = format;+ if (ext === 'json') detectedFormat = 'json';+ else if (ext === 'yaml' || ext === 'yml') detectedFormat = 'yaml';+ else if (ext === 'toml') detectedFormat = 'toml';++ const reader = new FileReader();+ reader.onload = (event) => {+ const text = event.target?.result;+ if (typeof text !== 'string') {+ setError('Failed to read file');+ return;+ }+ try {+ // Validate by parsing+ deserialize(text, detectedFormat);+ setFormat(detectedFormat);+ setEditorContent(text);+ setHasEdits(true);+ setError(null);+ setSnackbar({ message: `Loaded ${file.name} (${detectedFormat.toUpperCase()})`, severity: 'success' });+ } catch (err) {+ setError(`Invalid ${detectedFormat.toUpperCase()} in ${file.name}: ${err instanceof Error ? err.message : String(err)}`);+ }+ };+ reader.onerror = () => {+ setError(`Failed to read file: ${file.name}`);+ };+ reader.readAsText(file);++ // Reset the input so the same file can be re-selected+ e.target.value = '';+ }, [format]);++ const isDark = theme.palette.mode === 'dark';++ return (+ <Box sx={{ display: 'flex', flexDirection: 'column', height: '100%', gap: 1.5 }}>+ {/* Toolbar */}+ <Box+ sx={{+ display: 'flex',+ alignItems: 'center',+ justifyContent: 'space-between',+ flexWrap: 'wrap',+ gap: 1,+ }}+ >+ {/* Format selector */}+ <ButtonGroup size="small" variant="outlined">+ <FormatButton format="json" active={format === 'json'} onClick={() => handleFormatChange('json')} />+ <FormatButton format="yaml" active={format === 'yaml'} onClick={() => handleFormatChange('yaml')} />+ <FormatButton format="toml" active={format === 'toml'} onClick={() => handleFormatChange('toml')} />+ </ButtonGroup>++ {/* Action buttons */}+ <Box sx={{ display: 'flex', gap: 0.75 }}>+ <Tooltip title="Copy to clipboard">+ <Button size="small" variant="outlined" onClick={handleCopy} sx={{ minWidth: 0, px: 1 }}>+ <ContentCopyIcon sx={{ fontSize: 16 }} />+ </Button>+ </Tooltip>+ <Tooltip title="Upload settings file (.json, .yaml, .toml)">+ <Button size="small" variant="outlined" onClick={handleUploadClick} startIcon={<UploadFileIcon sx={{ fontSize: 16 }} />}>+ Upload+ </Button>+ </Tooltip>+ <Tooltip title={`Download as ${format.toUpperCase()}`}>+ <Button size="small" variant="outlined" onClick={handleDownload} startIcon={<DownloadIcon sx={{ fontSize: 16 }} />}>+ Download+ </Button>+ </Tooltip>++ <Divider orientation="vertical" flexItem sx={{ mx: 0.5 }} />++ <Tooltip title="Reset to current app state">+ <span>+ <Button+ size="small"+ variant="outlined"+ onClick={handleReset}+ disabled={!hasEdits}+ startIcon={<RestoreIcon sx={{ fontSize: 16 }} />}+ >+ Reset+ </Button>+ </span>+ </Tooltip>+ <Tooltip title="Apply edits to app">+ <span>+ <Button+ size="small"+ variant="contained"+ color="success"+ onClick={handleApply}+ disabled={!hasEdits}+ startIcon={<CheckIcon sx={{ fontSize: 16 }} />}+ >+ Apply+ </Button>+ </span>+ </Tooltip>+ </Box>+ </Box>++ {/* Status bar */}+ {hasEdits && (+ <Alert severity="info" sx={{ py: 0, fontSize: '0.75rem' }}>+ You have unsaved edits. Click <strong>Apply</strong> to push changes to the app, or <strong>Reset</strong> to discard.+ </Alert>+ )}+ {error && (+ <Alert severity="error" sx={{ py: 0, fontSize: '0.75rem' }}>+ {error}+ </Alert>+ )}++ {/* Monaco Editor */}+ <Box+ sx={{+ flex: 1,+ minHeight: 400,+ border: `1px solid ${theme.palette.divider}`,+ borderRadius: 1,+ overflow: 'hidden',+ }}+ >+ <Editor+ height="100%"+ language={FORMAT_MONACO_LANGUAGES[format]}+ value={editorContent}+ theme={isDark ? 'vs-dark' : 'light'}+ onChange={handleEditorChange}+ onMount={handleEditorMount}+ loading={+ <Box sx={{ display: 'flex', alignItems: 'center', justifyContent: 'center', height: '100%' }}>+ <CircularProgress size={32} />+ </Box>+ }+ options={{+ minimap: { enabled: false },+ fontSize: 13,+ fontFamily: "'JetBrains Mono', 'Fira Code', 'Cascadia Code', Consolas, monospace",+ lineNumbers: 'on',+ scrollBeyondLastLine: false,+ wordWrap: 'on',+ tabSize: 2,+ automaticLayout: true,+ renderWhitespace: 'selection',+ bracketPairColorization: { enabled: true },+ folding: true,+ formatOnPaste: true,+ }}+ />+ </Box>++ {/* Hidden file input for upload */}+ <input+ ref={fileInputRef}+ type="file"+ accept=".json,.yaml,.yml,.toml"+ style={{ display: 'none' }}+ onChange={handleFileSelected}+ />++ {/* Snackbar for feedback */}+ <Snackbar+ open={snackbar !== null}+ autoHideDuration={3000}+ onClose={() => setSnackbar(null)}+ anchorOrigin={{ vertical: 'bottom', horizontal: 'center' }}+ >+ {snackbar ? (+ <Alert+ onClose={() => setSnackbar(null)}+ severity={snackbar.severity}+ variant="filled"+ sx={{ width: '100%' }}+ >+ {snackbar.message}+ </Alert>+ ) : undefined}+ </Snackbar>+ </Box>+ );+};diff --git a/freemocap-ui/src/components/settings-editor/format-converters.ts b/freemocap-ui/src/components/settings-editor/format-converters.tsnew file mode 100644index 00000000..dab7ab60--- /dev/null+++ b/freemocap-ui/src/components/settings-editor/format-converters.ts@@ -0,0 +1,81 @@+import yaml from 'js-yaml';+import * as TOML from 'smol-toml';++export type SerializationFormat = 'json' | 'yaml' | 'toml';++/** Recursively remove null values from an object (TOML has no null concept). */+function stripNulls(obj: Record<string, unknown>): Record<string, unknown> {+ const result: Record<string, unknown> = {};+ for (const [key, value] of Object.entries(obj)) {+ if (value === null || value === undefined) continue;+ if (typeof value === 'object' && !Array.isArray(value)) {+ result[key] = stripNulls(value as Record<string, unknown>);+ } else {+ result[key] = value;+ }+ }+ return result;+}++export function serialize(data: Record<string, unknown>, format: SerializationFormat): string {+ switch (format) {+ case 'json':+ return JSON.stringify(data, null, 2);+ case 'yaml':+ return yaml.dump(data, {+ indent: 2,+ lineWidth: 120,+ noRefs: true,+ sortKeys: false,+ });+ case 'toml':+ // smol-toml expects a plain record; strip null values since TOML has no null+ return TOML.stringify(stripNulls(data) as any);+ }+}++export function deserialize(text: string, format: SerializationFormat): Record<string, unknown> {+ switch (format) {+ case 'json': {+ const parsed = JSON.parse(text);+ if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {+ throw new Error('JSON root must be an object');+ }+ return parsed as Record<string, unknown>;+ }+ case 'yaml': {+ const parsed = yaml.load(text);+ if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {+ throw new Error('YAML root must be a mapping');+ }+ return parsed as Record<string, unknown>;+ }+ case 'toml': {+ return TOML.parse(text) as Record<string, unknown>;+ }+ }+}++export function convertFormat(text: string, from: SerializationFormat, to: SerializationFormat): string {+ if (from === to) return text;+ const data = deserialize(text, from);+ return serialize(data, to);+}++export const FORMAT_EXTENSIONS: Record<SerializationFormat, string> = {+ json: '.json',+ yaml: '.yaml',+ toml: '.toml',+};++export const FORMAT_MIME_TYPES: Record<SerializationFormat, string> = {+ json: 'application/json',+ yaml: 'text/yaml',+ toml: 'application/toml',+};++export const FORMAT_MONACO_LANGUAGES: Record<SerializationFormat, string> = {+ json: 'json',+ yaml: 'yaml',+ toml: 'toml',+};diff --git a/freemocap-ui/src/components/setup-wizard/FirstLaunchRedirect.tsx b/freemocap-ui/src/components/setup-wizard/FirstLaunchRedirect.tsxnew file mode 100644index 00000000..2021bb52--- /dev/null+++ b/freemocap-ui/src/components/setup-wizard/FirstLaunchRedirect.tsx@@ -0,0 +1,26 @@+import React, { useEffect } from 'react';+import { useNavigate, useLocation } from 'react-router-dom';+import { useSetupWizardRequired } from '@/components/setup-wizard/SetupWizard';++/**+ * Invisible component that redirects to /setup on first launch.+ * Render this anywhere inside a HashRouter.+ * Once setup is complete (persisted to ~/.freemocap/settings.json),+ * this does nothing.+ */+export const FirstLaunchRedirect: React.FC = () => {+ const { loading, required } = useSetupWizardRequired();+ const navigate = useNavigate();+ const location = useLocation();++ useEffect(() => {+ if (loading) return;+ if (!required) return;+ // Don't redirect if we're already on the settings page+ if (location.pathname === '/settings') return;++ navigate('/settings', { replace: true });+ }, [loading, required, location.pathname, navigate]);++ return null;+};diff --git a/freemocap-ui/src/components/setup-wizard/SetupWizard.tsx b/freemocap-ui/src/components/setup-wizard/SetupWizard.tsxnew file mode 100644index 00000000..61c77eae--- /dev/null+++ b/freemocap-ui/src/components/setup-wizard/SetupWizard.tsx@@ -0,0 +1,758 @@+import React, { useState, useEffect, useCallback } from 'react';+import {+ Box,+ Typography,+ Button,+ LinearProgress,+ CircularProgress,+ Chip,+ Tooltip,+ Alert,+ Paper,+ Stepper,+ Step,+ StepLabel,+ IconButton,+} from '@mui/material';+import { useTheme } from '@mui/material/styles';+import CheckCircleIcon from '@mui/icons-material/CheckCircle';+import ErrorIcon from '@mui/icons-material/Error';+import WarningIcon from '@mui/icons-material/Warning';+import DownloadIcon from '@mui/icons-material/Download';+import RefreshIcon from '@mui/icons-material/Refresh';+import ComputerIcon from '@mui/icons-material/Computer';+import MemoryIcon from '@mui/icons-material/Memory';+import StorageIcon from '@mui/icons-material/Storage';+import SpeedIcon from '@mui/icons-material/Speed';+import VideocamIcon from '@mui/icons-material/Videocam';+import ArrowForwardIcon from '@mui/icons-material/ArrowForward';+import ArrowBackIcon from '@mui/icons-material/ArrowBack';+import CloseIcon from '@mui/icons-material/Close';+import { useElectronIPC } from '@/services';++// ── Types (mirrors electron-side types) ──++interface CpuInfo { model: string; cores: number; threads: number; speedMhz: number }+interface RamInfo { totalGb: number; availableGb: number }+interface GpuInfo { name: string; vendor: string; vramMb: number | null; cudaAvailable: boolean; cudaVersion: string | null }+interface DiskInfo { path: string; totalGb: number; freeGb: number }+interface OsInfo { platform: string; release: string; arch: string; hostname: string }+type PerformanceTier = 'basic' | 'standard' | 'advanced' | 'pro';+interface PerformanceRecommendation {+ tier: PerformanceTier;+ label: string;+ description: string;+ maxCameras: number;+ maxResolution: string;+ realtimeTracking: boolean;+ warnings: string[];+}+interface SystemScanResult {+ cpu: CpuInfo;+ ram: RamInfo;+ gpus: GpuInfo[];+ disk: DiskInfo;+ os: OsInfo;+ recommendation: PerformanceRecommendation;+ scannedAt: string;+}++type DependencyStatus = 'installed' | 'missing' | 'outdated' | 'checking' | 'installing' | 'error';+interface DependencyInfo {+ id: string;+ name: string;+ description: string;+ required: boolean;+ status: DependencyStatus;+ version: string | null;+ installedPath: string | null;+ error: string | null;+}++// ── Constants ──++const SETUP_COMPLETE_KEY = 'setupComplete';+const SYSTEM_SCAN_KEY = 'lastSystemScan';+const STEPS = ['System Scan', 'Dependencies', 'Ready'];++const TIER_COLORS: Record<PerformanceTier, string> = {+ basic: '#ff9800',+ standard: '#2196f3',+ advanced: '#4caf50',+ pro: '#00e5ff',+};++const TIER_EMOJIS: Record<PerformanceTier, string> = {+ basic: '🐢',+ standard: '🏃',+ advanced: '🚀',+ pro: '⚡',+};++// ── Status icon helper ──++function StatusIcon({ status }: { status: DependencyStatus }) {+ switch (status) {+ case 'installed':+ return <CheckCircleIcon sx={{ color: '#4caf50', fontSize: 20 }} />;+ case 'missing':+ return <ErrorIcon sx={{ color: '#f44336', fontSize: 20 }} />;+ case 'outdated':+ return <WarningIcon sx={{ color: '#ff9800', fontSize: 20 }} />;+ case 'checking':+ case 'installing':+ return <CircularProgress size={18} />;+ case 'error':+ return <ErrorIcon sx={{ color: '#f44336', fontSize: 20 }} />;+ }+}++// ── Step 0: System Scan ──++function SystemScanStep({+ scanResult,+ scanning,+ onRescan,+}: {+ scanResult: SystemScanResult | null;+ scanning: boolean;+ onRescan: () => void;+}) {+ const theme = useTheme();++ if (scanning) {+ return (+ <Box sx={{ textAlign: 'center', py: 6 }}>+ <CircularProgress size={48} />+ <Typography sx={{ mt: 2, color: theme.palette.text.secondary }}>+ Scanning your system...+ </Typography>+ </Box>+ );+ }++ if (!scanResult) {+ return (+ <Box sx={{ textAlign: 'center', py: 6 }}>+ <Typography color="error">Scan failed. Please retry.</Typography>+ <Button onClick={onRescan} startIcon={<RefreshIcon />} sx={{ mt: 2 }}>+ Retry Scan+ </Button>+ </Box>+ );+ }++ const { cpu, ram, gpus, disk, os: osInfo, recommendation } = scanResult;+ const tierColor = TIER_COLORS[recommendation.tier];++ return (+ <Box sx={{ display: 'flex', flexDirection: 'column', gap: 2 }}>+ {/* Performance Tier Badge */}+ <Paper+ elevation={0}+ sx={{+ p: 2,+ border: `2px solid ${tierColor}`,+ borderRadius: 2,+ background: `${tierColor}11`,+ textAlign: 'center',+ }}+ >+ <Typography variant="h5" sx={{ fontWeight: 700, color: tierColor }}>+ {TIER_EMOJIS[recommendation.tier]} {recommendation.label} System+ </Typography>+ <Typography variant="body2" sx={{ mt: 0.5, color: theme.palette.text.secondary }}>+ {recommendation.description}+ </Typography>+ <Box sx={{ display: 'flex', justifyContent: 'center', gap: 2, mt: 1.5, flexWrap: 'wrap' }}>+ <Chip+ icon={<VideocamIcon />}+ label={`Up to ${recommendation.maxCameras} cameras`}+ size="small"+ sx={{ borderColor: tierColor, color: tierColor }}+ variant="outlined"+ />+ <Chip+ label={`${recommendation.maxResolution} max`}+ size="small"+ sx={{ borderColor: tierColor, color: tierColor }}+ variant="outlined"+ />+ {recommendation.realtimeTracking && (+ <Chip+ icon={<SpeedIcon />}+ label="Real-time tracking"+ size="small"+ sx={{ borderColor: tierColor, color: tierColor }}+ variant="outlined"+ />+ )}+ </Box>+ </Paper>++ {/* Hardware Details Grid */}+ <Box sx={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 1.5 }}>+ {/* CPU */}+ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>+ <MemoryIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>+ CPU+ </Typography>+ </Box>+ <Typography variant="body2" sx={{ fontWeight: 500, fontSize: '0.8rem' }}>+ {cpu.model}+ </Typography>+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>+ {cpu.threads} threads • {cpu.cores} cores • {cpu.speedMhz} MHz+ </Typography>+ </Paper>++ {/* RAM */}+ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>+ <ComputerIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>+ MEMORY+ </Typography>+ </Box>+ <Typography variant="body2" sx={{ fontWeight: 500 }}>+ {ram.totalGb} GB total+ </Typography>+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>+ {ram.availableGb} GB available+ </Typography>+ </Paper>++ {/* GPU */}+ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>+ <SpeedIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>+ GPU+ </Typography>+ </Box>+ {gpus.length > 0 ? gpus.map((gpu, i) => (+ <Box key={i}>+ <Typography variant="body2" sx={{ fontWeight: 500, fontSize: '0.8rem' }}>+ {gpu.name}+ </Typography>+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>+ {gpu.vramMb ? `${Math.round(gpu.vramMb / 1024)} GB VRAM` : 'VRAM unknown'}+ {gpu.cudaAvailable ? ` • CUDA ${gpu.cudaVersion || '✓'}` : ''}+ </Typography>+ </Box>+ )) : (+ <Typography variant="body2" sx={{ color: theme.palette.text.disabled }}>+ No dedicated GPU detected+ </Typography>+ )}+ </Paper>++ {/* Disk */}+ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>+ <StorageIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>+ DISK+ </Typography>+ </Box>+ <Typography variant="body2" sx={{ fontWeight: 500 }}>+ {disk.freeGb} GB free+ </Typography>+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>+ of {disk.totalGb} GB total+ </Typography>+ {disk.freeGb > 0 && disk.freeGb < 20 && (+ <LinearProgress+ variant="determinate"+ value={((disk.totalGb - disk.freeGb) / disk.totalGb) * 100}+ color="warning"+ sx={{ mt: 0.5, height: 4, borderRadius: 1 }}+ />+ )}+ </Paper>+ </Box>++ {/* Warnings */}+ {recommendation.warnings.length > 0 && (+ <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.5 }}>+ {recommendation.warnings.map((w, i) => (+ <Alert key={i} severity="warning" sx={{ py: 0, fontSize: '0.75rem' }}>+ {w}+ </Alert>+ ))}+ </Box>+ )}++ {/* Rescan button */}+ <Box sx={{ display: 'flex', justifyContent: 'flex-end' }}>+ <Button size="small" startIcon={<RefreshIcon />} onClick={onRescan}>+ Rescan+ </Button>+ </Box>+ </Box>+ );+}++// ── Step 1: Dependencies ──++function DependenciesStep({+ dependencies,+ installing,+ onInstall,+ onRefresh,+}: {+ dependencies: DependencyInfo[];+ installing: string | null;+ onInstall: (id: string) => void;+ onRefresh: () => void;+}) {+ const theme = useTheme();++ if (dependencies.length === 0) {+ return (+ <Box sx={{ textAlign: 'center', py: 6 }}>+ <CircularProgress size={48} />+ <Typography sx={{ mt: 2, color: theme.palette.text.secondary }}>+ Checking dependencies...+ </Typography>+ </Box>+ );+ }++ const required = dependencies.filter(d => d.required);+ const optional = dependencies.filter(d => !d.required);++ return (+ <Box sx={{ display: 'flex', flexDirection: 'column', gap: 2 }}>+ {/* Required */}+ <Box>+ <Typography variant="subtitle2" sx={{ mb: 1, color: theme.palette.text.secondary, fontWeight: 600 }}>+ REQUIRED+ </Typography>+ <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1 }}>+ {required.map(dep => (+ <DependencyRow+ key={dep.id}+ dep={dep}+ installing={installing === dep.id}+ onInstall={() => onInstall(dep.id)}+ />+ ))}+ </Box>+ </Box>++ {/* Optional */}+ <Box>+ <Typography variant="subtitle2" sx={{ mb: 1, color: theme.palette.text.secondary, fontWeight: 600 }}>+ OPTIONAL+ </Typography>+ <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1 }}>+ {optional.map(dep => (+ <DependencyRow+ key={dep.id}+ dep={dep}+ installing={installing === dep.id}+ onInstall={() => onInstall(dep.id)}+ />+ ))}+ </Box>+ </Box>++ <Box sx={{ display: 'flex', justifyContent: 'flex-end' }}>+ <Button size="small" startIcon={<RefreshIcon />} onClick={onRefresh}>+ Recheck All+ </Button>+ </Box>+ </Box>+ );+}++function DependencyRow({+ dep,+ installing,+ onInstall,+}: {+ dep: DependencyInfo;+ installing: boolean;+ onInstall: () => void;+}) {+ const theme = useTheme();+ const canInstall = dep.status === 'missing' || dep.status === 'outdated';+ const isCuda = dep.id === 'cuda';++ return (+ <Paper+ elevation={0}+ sx={{+ p: 1.5,+ border: `1px solid ${theme.palette.divider}`,+ borderRadius: 1,+ display: 'flex',+ alignItems: 'center',+ gap: 1.5,+ }}+ >+ <StatusIcon status={installing ? 'installing' : dep.status} />++ <Box sx={{ flex: 1, minWidth: 0 }}>+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>+ <Typography variant="body2" sx={{ fontWeight: 600 }}>+ {dep.name}+ </Typography>+ {dep.version && (+ <Chip label={dep.version} size="small" sx={{ height: 18, fontSize: '0.65rem' }} />+ )}+ {dep.required && (+ <Chip label="required" size="small" color="warning" variant="outlined" sx={{ height: 18, fontSize: '0.6rem' }} />+ )}+ </Box>+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>+ {dep.description}+ </Typography>+ {dep.error && (+ <Typography variant="caption" sx={{ display: 'block', color: theme.palette.error.main, mt: 0.25 }}>+ {dep.error}+ </Typography>+ )}+ {dep.installedPath && dep.status === 'installed' && (+ <Tooltip title={dep.installedPath}>+ <Typography+ variant="caption"+ sx={{+ display: 'block',+ color: theme.palette.text.disabled,+ fontSize: '0.6rem',+ overflow: 'hidden',+ textOverflow: 'ellipsis',+ whiteSpace: 'nowrap',+ maxWidth: 300,+ }}+ >+ {dep.installedPath}+ </Typography>+ </Tooltip>+ )}+ </Box>++ {canInstall && !isCuda && (+ <Button+ size="small"+ variant="contained"+ startIcon={installing ? <CircularProgress size={14} color="inherit" /> : <DownloadIcon />}+ onClick={onInstall}+ disabled={installing}+ sx={{ textTransform: 'none', fontSize: '0.75rem', whiteSpace: 'nowrap' }}+ >+ {installing ? 'Installing...' : dep.status === 'outdated' ? 'Update' : 'Install'}+ </Button>+ )}+ {canInstall && isCuda && (+ <Tooltip title="CUDA must be installed manually from the NVIDIA website">+ <Typography variant="caption" sx={{ color: theme.palette.text.disabled, fontStyle: 'italic' }}>+ Manual install+ </Typography>+ </Tooltip>+ )}+ </Paper>+ );+}++// ── Step 2: Ready ──++function ReadyStep({ scanResult }: { scanResult: SystemScanResult | null }) {+ const theme = useTheme();+ const tier = scanResult?.recommendation.tier ?? 'standard';+ const tierColor = TIER_COLORS[tier];++ return (+ <Box sx={{ textAlign: 'center', py: 4 }}>+ <CheckCircleIcon sx={{ fontSize: 64, color: '#4caf50', mb: 2 }} />+ <Typography variant="h5" sx={{ fontWeight: 700, mb: 1 }}>+ You're all set!+ </Typography>+ <Typography sx={{ color: theme.palette.text.secondary, mb: 3, maxWidth: 400, mx: 'auto' }}>+ FreeMoCap is ready to go. You can always re-run this setup from the settings menu.+ </Typography>++ {scanResult && (+ <Box sx={{ display: 'flex', justifyContent: 'center', gap: 1, flexWrap: 'wrap' }}>+ <Chip+ label={`${scanResult.recommendation.label} System`}+ sx={{ borderColor: tierColor, color: tierColor, fontWeight: 600 }}+ variant="outlined"+ />+ <Chip+ label={`Up to ${scanResult.recommendation.maxCameras} cameras @ ${scanResult.recommendation.maxResolution}`}+ variant="outlined"+ size="small"+ />+ </Box>+ )}+ </Box>+ );+}++// ── Main Wizard ──++interface SetupWizardProps {+ onComplete: () => void;+ /** When true, always shows the wizard regardless of persisted state */+ forceShow?: boolean;+}++export const SetupWizard: React.FC<SetupWizardProps> = ({ onComplete, forceShow = false }) => {+ const theme = useTheme();+ const { isElectron, api } = useElectronIPC();++ const [activeStep, setActiveStep] = useState(0);+ const [scanning, setScanning] = useState(false);+ const [scanResult, setScanResult] = useState<SystemScanResult | null>(null);+ const [dependencies, setDependencies] = useState<DependencyInfo[]>([]);+ const [installing, setInstalling] = useState<string | null>(null);++ // ── System scan ──++ const runScan = useCallback(async () => {+ if (!isElectron || !api) return;+ setScanning(true);+ try {+ const result = await api.system.scan.query();+ const typed = result as SystemScanResult;+ setScanResult(typed);+ // Persist scan result to ~/.freemocap/settings.json+ await api.settings.set.mutate({ key: SYSTEM_SCAN_KEY, value: typed });+ } catch (err) {+ console.error('System scan failed:', err);+ } finally {+ setScanning(false);+ }+ }, [isElectron, api]);++ // ── Dependency detection ──++ const detectDeps = useCallback(async () => {+ if (!isElectron || !api) return;+ try {+ const result = await api.dependencies.detectAll.query();+ setDependencies(result as DependencyInfo[]);+ } catch (err) {+ console.error('Dependency detection failed:', err);+ }+ }, [isElectron, api]);++ // ── Install a dependency ──++ const installDep = useCallback(async (depId: string) => {+ if (!isElectron || !api) return;+ setInstalling(depId);+ try {+ const updated = await api.dependencies.install.mutate({ dependencyId: depId });+ setDependencies(prev =>+ prev.map(d => d.id === depId ? (updated as DependencyInfo) : d),+ );++ // After installing uv, re-detect python-env too (it depends on uv)+ if (depId === 'uv') {+ const envInfo = await api.dependencies.detect.query({ dependencyId: 'python-env' });+ setDependencies(prev =>+ prev.map(d => d.id === 'python-env' ? (envInfo as DependencyInfo) : d),+ );+ }+ } catch (err) {+ console.error(`Failed to install ${depId}:`, err);+ setDependencies(prev =>+ prev.map(d =>+ d.id === depId+ ? { ...d, status: 'error' as DependencyStatus, error: err instanceof Error ? err.message : String(err) }+ : d,+ ),+ );+ } finally {+ setInstalling(null);+ }+ }, [isElectron, api]);++ // ── Load persisted scan result on mount ──++ useEffect(() => {+ if (!isElectron || !api) return;+ api.settings.get.query({ key: SYSTEM_SCAN_KEY }).then(result => {+ if (result && typeof result === 'object' && 'cpu' in (result as object)) {+ setScanResult(result as SystemScanResult);+ }+ }).catch(() => { /* no persisted scan — will run fresh */ });+ }, [isElectron, api]);++ // ── Auto-run on step change ──++ useEffect(() => {+ if (activeStep === 0 && !scanResult && !scanning) {+ runScan();+ }+ }, [activeStep, scanResult, scanning, runScan]);++ useEffect(() => {+ if (activeStep === 1 && dependencies.length === 0) {+ detectDeps();+ }+ }, [activeStep, dependencies.length, detectDeps]);++ // ── Completion ──++ const handleFinish = useCallback(() => {+ if (isElectron && api) {+ api.settings.set.mutate({ key: SETUP_COMPLETE_KEY, value: true }).catch(err => {+ console.error('Failed to persist setup complete state:', err);+ });+ }+ onComplete();+ }, [onComplete, isElectron, api]);++ // ── Navigation ──++ const canProceed = (): boolean => {+ if (activeStep === 0) return scanResult !== null;+ if (activeStep === 1) return true; // Dependencies are not blocking+ return true;+ };++ // If not in Electron, show a simple non-Electron message+ if (!isElectron) {+ return (+ <Box sx={{ p: 4, textAlign: 'center' }}>+ <Typography variant="h6" sx={{ mb: 2 }}>Setup Wizard</Typography>+ <Typography sx={{ color: theme.palette.text.secondary, mb: 3 }}>+ The setup wizard is only available in the desktop app.+ Connect to a running FreeMoCap server to get started.+ </Typography>+ <Button variant="contained" onClick={onComplete}>Continue</Button>+ </Box>+ );+ }++ return (+ <Box+ sx={{+ width: '100%',+ maxWidth: 640,+ mx: 'auto',+ p: 3,+ display: 'flex',+ flexDirection: 'column',+ gap: 2,+ }}+ >+ {/* Header */}+ <Box sx={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>+ <Typography variant="h6" sx={{ fontWeight: 700 }}>+ FreeMoCap Setup+ </Typography>+ <Tooltip title="Skip setup">+ <IconButton size="small" onClick={handleFinish}>+ <CloseIcon sx={{ fontSize: 18 }} />+ </IconButton>+ </Tooltip>+ </Box>++ {/* Stepper */}+ <Stepper activeStep={activeStep} alternativeLabel sx={{ mb: 1 }}>+ {STEPS.map(label => (+ <Step key={label}>+ <StepLabel>{label}</StepLabel>+ </Step>+ ))}+ </Stepper>++ {/* Step Content */}+ <Box sx={{ minHeight: 300 }}>+ {activeStep === 0 && (+ <SystemScanStep+ scanResult={scanResult}+ scanning={scanning}+ onRescan={runScan}+ />+ )}+ {activeStep === 1 && (+ <DependenciesStep+ dependencies={dependencies}+ installing={installing}+ onInstall={installDep}+ onRefresh={detectDeps}+ />+ )}+ {activeStep === 2 && (+ <ReadyStep scanResult={scanResult} />+ )}+ </Box>++ {/* Navigation Buttons */}+ <Box sx={{ display: 'flex', justifyContent: 'space-between', mt: 1 }}>+ <Button+ disabled={activeStep === 0}+ onClick={() => setActiveStep(prev => prev - 1)}+ startIcon={<ArrowBackIcon />}+ sx={{ textTransform: 'none' }}+ >+ Back+ </Button>++ {activeStep < STEPS.length - 1 ? (+ <Button+ variant="contained"+ disabled={!canProceed()}+ onClick={() => setActiveStep(prev => prev + 1)}+ endIcon={<ArrowForwardIcon />}+ sx={{ textTransform: 'none' }}+ >+ Next+ </Button>+ ) : (+ <Button+ variant="contained"+ color="success"+ onClick={handleFinish}+ sx={{ textTransform: 'none', fontWeight: 600 }}+ >+ Get Started+ </Button>+ )}+ </Box>+ </Box>+ );+};++// ── Hook: should the wizard be shown? ──+// Reads from ~/.freemocap/settings.json via electron IPC.+// Returns { loading, required } — `required` is true until we've confirmed+// the file says setup is complete.++export function useSetupWizardRequired(): { loading: boolean; required: boolean } {+ const { isElectron, api } = useElectronIPC();+ const [loading, setLoading] = useState(true);+ const [required, setRequired] = useState(true);++ useEffect(() => {+ if (!isElectron || !api) {+ // Not in Electron — never show the wizard+ setRequired(false);+ setLoading(false);+ return;+ }++ api.settings.get.query({ key: SETUP_COMPLETE_KEY })+ .then(value => {+ setRequired(value !== true);+ })+ .catch(() => {+ // Settings file doesn't exist yet — setup is required+ setRequired(true);+ })+ .finally(() => {+ setLoading(false);+ });+ }, [isElectron, api]);++ return { loading, required };+}\ No newline at end of filediff --git a/freemocap-ui/src/components/ui-components/LeftSidePanelContent.tsx b/freemocap-ui/src/components/ui-components/LeftSidePanelContent.tsxindex a4b1f607..8cb8ec8d 100644--- a/freemocap-ui/src/components/ui-components/LeftSidePanelContent.tsx+++ b/freemocap-ui/src/components/ui-components/LeftSidePanelContent.tsx@@ -1,72 +1,172 @@-// freemocap-ui/src/components/ui-components/LeftSidePanelContent.tsx-import * as React from 'react';-import Box from "@mui/material/Box";-import {IconButton, List, ListItem, useTheme} from "@mui/material";-import ThemeToggle from "@/components/ui-components/ThemeToggle";+import React, { useCallback, useMemo, useState } from 'react';+import Box from '@mui/material/Box';+import { IconButton, List, ListItem, Tooltip, useTheme } from '@mui/material';+import {+ closestCenter,+ DndContext,+ DragEndEvent,+ KeyboardSensor,+ PointerSensor,+ useSensor,+ useSensors,+} from '@dnd-kit/core';+import {+ arrayMove,+ SortableContext,+ sortableKeyboardCoordinates,+ verticalListSortingStrategy,+} from '@dnd-kit/sortable';+import { restrictToVerticalAxis, restrictToParentElement } from '@dnd-kit/modifiers';+import ThemeToggle from '@/components/ui-components/ThemeToggle';import HomeIcon from '@mui/icons-material/Home';-import {useLocation, useNavigate} from "react-router-dom";+import { useLocation, useNavigate } from 'react-router-dom';import VideocamIcon from '@mui/icons-material/Videocam';import DirectionsRunIcon from '@mui/icons-material/DirectionsRun';-import {VideoFolderPanel} from "@/components/video-folder-panel/VideoFolderPanel";-import {CameraConfigTreeView} from "@/components/camera-config-tree-view/CameraConfigTreeView";-import {ServerConnectionStatus} from "@/components/ServerConnectionStatus";-import {ProcessingPipelinePanel} from "@/components/processing-pipeline-panel/ProcessingPipelinePanel";-import {CalibrationControlPanel} from "@/components/calibration-task-panel/CalibrationControlPanel";-import {MocapTaskTreeItem} from "@/components/mocap-task-panel/MocapTaskTreeItem";-import {RecordingInfoPanel} from "@/components/recording-info-panel/RecordingInfoPanel";--// Extract reusable scrollbar styles+import TuneIcon from '@mui/icons-material/Tune';+import { VideoFolderPanel } from '@/components/video-folder-panel/VideoFolderPanel';+import { SortableSectionWrapper } from '@/components/common/SortableSectionWrapper';+import { ServerConnectionStatus } from '@/components/ServerConnectionStatus';+import { ProcessingPipelinePanel } from '@/components/processing-pipeline-panel/ProcessingPipelinePanel';+import { CameraConfigTreeView } from '@/components/camera-config-tree-view/CameraConfigTreeView';+import { CalibrationControlPanel } from '@/components/calibration-control-panel/CalibrationControlPanel';+import { MocapTaskTreeItem } from '@/components/mocap-control-panel/MocapTaskTreeItem';++const STORAGE_KEY = 'freemocap-sidebar-section-order';++const DEFAULT_SECTION_ORDER = [+ 'connection',+ 'pipeline',+ 'cameras',+ 'calibration',+ 'mocap',+] as const;++type SectionId = (typeof DEFAULT_SECTION_ORDER)[number];++const SECTION_COMPONENTS: Record<SectionId, React.FC> = {+ connection: ServerConnectionStatus,+ pipeline: ProcessingPipelinePanel,+ cameras: CameraConfigTreeView,+ calibration: CalibrationControlPanel,+ mocap: MocapTaskTreeItem,+};++function loadSectionOrder(): SectionId[] {+ try {+ const stored = localStorage.getItem(STORAGE_KEY);+ if (!stored) return [...DEFAULT_SECTION_ORDER];+ const parsed = JSON.parse(stored) as string[];+ const defaultSet = new Set<string>(DEFAULT_SECTION_ORDER);+ const parsedSet = new Set(parsed);+ if (+ parsed.length !== DEFAULT_SECTION_ORDER.length ||+ !parsed.every((id) => defaultSet.has(id)) ||+ !DEFAULT_SECTION_ORDER.every((id) => parsedSet.has(id))+ ) {+ return [...DEFAULT_SECTION_ORDER];+ }+ return parsed as SectionId[];+ } catch {+ return [...DEFAULT_SECTION_ORDER];+ }+}++function saveSectionOrder(order: SectionId[]): void {+ try {+ localStorage.setItem(STORAGE_KEY, JSON.stringify(order));+ } catch {+ // Storage full or unavailable — silently ignore+ }+}+const scrollbarStyles = {'&::-webkit-scrollbar': {width: '6px',backgroundColor: 'transparent',},'&::-webkit-scrollbar-thumb': {- backgroundColor: (theme: { palette: { mode: string; }; }) => theme.palette.mode === 'dark'- ? 'rgba(255, 255, 255, 0.2)'- : 'rgba(0, 0, 0, 0.2)',+ backgroundColor: (theme: { palette: { mode: string } }) =>+ theme.palette.mode === 'dark'+ ? 'rgba(255, 255, 255, 0.2)'+ : 'rgba(0, 0, 0, 0.2)',borderRadius: '3px','&:hover': {- backgroundColor: (theme: { palette: { mode: string; }; }) => theme.palette.mode === 'dark'- ? 'rgba(255, 255, 255, 0.3)'- : 'rgba(0, 0, 0, 0.3)',+ backgroundColor: (theme: { palette: { mode: string } }) =>+ theme.palette.mode === 'dark'+ ? 'rgba(255, 255, 255, 0.3)'+ : 'rgba(0, 0, 0, 0.3)',},},'&::-webkit-scrollbar-track': {backgroundColor: 'transparent',},scrollbarWidth: 'thin',- scrollbarColor: (theme: { palette: { mode: string; }; }) => theme.palette.mode === 'dark'- ? 'rgba(255, 255, 255, 0.2) transparent'- : 'rgba(0, 0, 0, 0.2) transparent',+ scrollbarColor: (theme: { palette: { mode: string } }) =>+ theme.palette.mode === 'dark'+ ? 'rgba(255, 255, 255, 0.2) transparent'+ : 'rgba(0, 0, 0, 0.2) transparent',};export const LeftSidePanelContent = () => {const theme = useTheme();const navigate = useNavigate();const location = useLocation();+ const [sectionOrder, setSectionOrder] = useState<SectionId[]>(loadSectionOrder);++ const sensors = useSensors(+ useSensor(PointerSensor, {+ activationConstraint: {+ distance: 5,+ },+ }),+ useSensor(KeyboardSensor, {+ coordinateGetter: sortableKeyboardCoordinates,+ }),+ );++ const handleDragEnd = useCallback((event: DragEndEvent) => {+ const { active, over } = event;+ if (!over || active.id === over.id) return;++ setSectionOrder((prev) => {+ const oldIndex = prev.indexOf(active.id as SectionId);+ const newIndex = prev.indexOf(over.id as SectionId);+ const newOrder = arrayMove(prev, oldIndex, newIndex);+ saveSectionOrder(newOrder);+ return newOrder;+ });+ }, []);++ const modifiers = useMemo(+ () => [restrictToVerticalAxis, restrictToParentElement],+ [],+ );return (- <Box sx={{- width: '100%',- height: '100%',- backgroundColor: theme.palette.mode === 'dark'- ? theme.palette.background.paper- : theme.palette.grey[50],- color: theme.palette.text.primary,- display: 'flex',- flexDirection: 'column',- overflowY: 'auto',- overflowX: 'hidden',- ...scrollbarStyles- }}>+ <Box+ sx={{+ width: '100%',+ height: '100%',+ backgroundColor:+ theme.palette.mode === 'dark'+ ? theme.palette.background.paper+ : theme.palette.grey[50],+ color: theme.palette.text.primary,+ display: 'flex',+ flexDirection: 'column',+ overflowY: 'auto',+ overflowX: 'hidden',+ ...scrollbarStyles,+ }}+ >{/* Header */}<List disablePadding><ListItemsx={{- borderBottom: theme.palette.mode === 'dark'- ? '1px solid rgba(255,255,255,0.08)'- : '1px solid rgba(0,0,0,0.08)',+ borderBottom:+ theme.palette.mode === 'dark'+ ? '1px solid rgba(255,255,255,0.08)'+ : '1px solid rgba(0,0,0,0.08)',py: 0.75,px: 1.5,minHeight: 40,@@ -80,19 +180,22 @@ export const LeftSidePanelContent = () => {sx={{fontSize: 16,fontWeight: 600,- color: theme.palette.text.primary+ color: theme.palette.text.primary,}}>FreeMoCap 💀📸</Box>- <Box sx={{display: 'flex', alignItems: 'center', gap: 0.25}}>+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.25 }}><IconButtonsize="small"onClick={() => navigate('/')}sx={{padding: '4px',- color: location.pathname === '/' ? theme.palette.success.main : theme.palette.text.secondary+ color:+ location.pathname === '/'+ ? theme.palette.success.main+ : theme.palette.text.secondary,}}><HomeIcon sx={{ fontSize: 18 }} />@@ -101,7 +204,7 @@ export const LeftSidePanelContent = () => {color="inherit"onClick={() => navigate('/viewport3d')}>- <DirectionsRunIcon/>+ <DirectionsRunIcon /></IconButton><IconButton@@ -109,45 +212,79 @@ export const LeftSidePanelContent = () => {onClick={() => navigate('/cameras')}sx={{padding: '4px',- color: location.pathname === '/cameras' ? theme.palette.success.main : theme.palette.text.secondary+ color:+ location.pathname === '/cameras'+ ? theme.palette.success.main+ : theme.palette.text.secondary,}}><VideocamIcon sx={{ fontSize: 18 }} /></IconButton>- <ThemeToggle/>+ <Tooltip title="Settings">+ <IconButton+ size="small"+ onClick={() => navigate('/settings')}+ sx={{+ padding: '4px',+ color:+ location.pathname === '/settings'+ ? theme.palette.success.main+ : theme.palette.text.secondary,+ }}+ >+ <TuneIcon sx={{ fontSize: 18 }} />+ </IconButton>+ </Tooltip>++ <ThemeToggle /></Box></ListItem></List>- {/* Server Settings - Compact */}- <ServerConnectionStatus/>-{/* Video Panel for Videos Page */}{location.pathname === '/videos' && (- <Box sx={{- borderTop: '1px solid',- borderColor: theme.palette.divider,- }}>- <VideoFolderPanel/>+ <Box+ sx={{+ borderTop: '1px solid',+ borderColor: theme.palette.divider,+ }}+ >+ <VideoFolderPanel /></Box>)}- {/* Main Content Area */}- <Box sx={{- display: 'flex',- flexDirection: 'column',- gap: 0.5,- pt: 0.5,- pb: 2,- }}>- <ProcessingPipelinePanel/>- <CameraConfigTreeView/>- {/*<RecordingInfoPanel/>*/}- <CalibrationControlPanel />- <MocapTaskTreeItem />-- </Box>+ {/* Sidebar Sections — drag-reorderable */}+ <DndContext+ sensors={sensors}+ collisionDetection={closestCenter}+ modifiers={modifiers}+ onDragEnd={handleDragEnd}+ >+ <SortableContext+ items={sectionOrder}+ strategy={verticalListSortingStrategy}+ >+ <Box+ sx={{+ display: 'flex',+ flexDirection: 'column',+ gap: 0.75,+ p: 0.75,+ pb: 2,+ }}+ >+ {sectionOrder.map((sectionId) => {+ const Component = SECTION_COMPONENTS[sectionId];+ return (+ <SortableSectionWrapper key={sectionId} id={sectionId}>+ <Component />+ </SortableSectionWrapper>+ );+ })}+ </Box>+ </SortableContext>+ </DndContext></Box>);-}+};diff --git a/freemocap-ui/src/components/viewport3d/ImageMesh.tsx b/freemocap-ui/src/components/viewport3d/ImageMesh.tsxindex a1edca6a..3442bd69 100644--- a/freemocap-ui/src/components/viewport3d/ImageMesh.tsx+++ b/freemocap-ui/src/components/viewport3d/ImageMesh.tsx@@ -1,7 +1,7 @@-import {useEffect, useMemo, useRef} from 'react';-import {useFrame} from '@react-three/fiber';+import { useEffect, useMemo, useRef } from 'react';+import { useFrame } from '@react-three/fiber';import * as THREE from 'three';-import {useServer} from '@/services';+import { useServer } from '@/services';interface ImageMeshProps {cameraId: string;@@ -15,9 +15,9 @@ export function ImageMesh({ cameraId, position }: ImageMeshProps) {const textureRef = useRef<THREE.Texture | null>(null);const hasNewFrameRef = useRef<boolean>(false);- // FIX 1: Change from CanvasTexture to Texture+ // Base texture — updated each frame with the latest ImageBitmapconst texture = useMemo(() => {- const tex = new THREE.Texture(); // ← Changed from CanvasTexture+ const tex = new THREE.Texture();tex.minFilter = THREE.LinearFilter;tex.magFilter = THREE.LinearFilter;tex.format = THREE.RGBAFormat;@@ -33,10 +33,9 @@ export function ImageMesh({ cameraId, position }: ImageMeshProps) {});}, [texture]);- // FIX 2: Subscribe with cameraId parameter+ // Stream camera frames as ImageBitmapsuseEffect(() => {const unsubscribe = subscribeToFrames(cameraId, (bitmap) => {- // Close previous bitmap to free memoryif (currentBitmapRef.current) {currentBitmapRef.current.close();}@@ -53,7 +52,7 @@ export function ImageMesh({ cameraId, position }: ImageMeshProps) {};}, [cameraId, subscribeToFrames]);- // Update texture in render loop+ // Push the latest bitmap to the GPU texture each frameuseFrame(() => {if (hasNewFrameRef.current && currentBitmapRef.current && textureRef.current) {textureRef.current.image = currentBitmapRef.current;diff --git a/freemocap-ui/src/components/viewport3d/RigidBodyRenderer.tsx b/freemocap-ui/src/components/viewport3d/RigidBodyRenderer.tsxnew file mode 100644index 00000000..4623d64f--- /dev/null+++ b/freemocap-ui/src/components/viewport3d/RigidBodyRenderer.tsx@@ -0,0 +1,171 @@+import { useEffect, useMemo, useRef } from "react";+import {+ InstancedMesh,+ MeshStandardMaterial,+ CylinderGeometry,+ Object3D,+ Vector3,+} from "three";+import { useFrame } from "@react-three/fiber";+import { useServer } from "@/services";+import { RigidBodyPose } from "@/components/viewport3d/viewport3d-types";+import { Z_OFFSET } from "@/components/viewport3d/skeleton-config";+import { SKELETON_COLORS } from "@/components/viewport3d/skeleton-colors";++/** Maximum bone segments the instanced mesh can hold. */+const MAX_RIGID_BODIES = 64;++/** Cylinder cross-section radius in meters. */+const BODY_RADIUS = 0.025;+const HAND_RADIUS = 0.008;++const DUMMY = new Object3D();+const FAR_AWAY = new Vector3(10000, 10000, 10000);++function getRigidBodyColor(boneKey: string): Color {+ if (boneKey.includes("left_hand")) return SKELETON_COLORS.leftHand;+ if (boneKey.includes("right_hand")) return SKELETON_COLORS.rightHand;+ if (boneKey.includes("left")) return SKELETON_COLORS.left;+ if (boneKey.includes("right")) return SKELETON_COLORS.right;+ return SKELETON_COLORS.center;+}++function getRigidBodyRadius(boneKey: string): number {+ if (boneKey.includes("hand")) return HAND_RADIUS;+ return BODY_RADIUS;+}++/**+ * Renders rigid body bone segments as instanced cylinders.+ *+ * Subscribes directly to the server's rigid-body stream and updates+ * only dirty instances each frame to minimize GPU uploads. Follows the+ * same mutable-ref + useFrame pattern as SkeletonRenderer.+ */+export function RigidBodyRenderer() {+ const { subscribeToRigidBodies } = useServer();+ const instancedMeshRef = useRef<InstancedMesh>(null);++ // Mutable refs for frame-loop access without React re-renders+ const rigidBodiesRef = useRef<Map<string, RigidBodyPose>>(new Map());+ const boneKeyToIndexRef = useRef<Map<string, number>>(new Map());+ const indexToBoneKeyRef = useRef<Map<number, string>>(new Map());+ const nextIndexRef = useRef<number>(0);+ const dirtyRef = useRef<boolean>(false);++ // Unit cylinder centered at origin along +Y, then:+ // - rotated so axis is +Z+ // - translated so bottom face is at origin (extends 0 → +1 along Z)+ // This way scale.z = bone length places the cylinder from parent → child.+ const cylinderGeometry = useMemo(() => {+ const geo = new CylinderGeometry(1, 1, 1, 8, 1);+ geo.rotateX(Math.PI / 2); // +Y axis → +Z axis+ geo.translate(0, 0, 0.5); // origin at bottom face (parent joint)+ return geo;+ }, []);++ // Semi-transparent material — per-instance color tints it+ const cylinderMaterial = useMemo(() => new MeshStandardMaterial({+ color: '#ffffff',+ roughness: 0.45,+ metalness: 0.3,+ transparent: true,+ opacity: 0.6,+ }), []);++ // Assign stable instance index for a bone key+ const assignIndex = (boneKey: string): number => {+ if (nextIndexRef.current >= MAX_RIGID_BODIES) {+ throw new Error(`Maximum rigid bodies (${MAX_RIGID_BODIES}) exceeded for bone "${boneKey}"`);+ }+ const index = nextIndexRef.current++;+ boneKeyToIndexRef.current.set(boneKey, index);+ indexToBoneKeyRef.current.set(index, boneKey);+ return index;+ };++ // Subscribe to rigid body stream+ useEffect(() => {+ const unsubscribe = subscribeToRigidBodies((newPoses: Map<string, RigidBodyPose>) => {+ rigidBodiesRef.current = newPoses;+ dirtyRef.current = true;++ // Assign indices for any new bones+ for (const boneKey of newPoses.keys()) {+ if (!boneKeyToIndexRef.current.has(boneKey)) {+ assignIndex(boneKey);+ }+ }+ });++ return unsubscribe;+ }, [subscribeToRigidBodies]);++ // Initialize all instances as hidden+ useEffect(() => {+ if (!instancedMeshRef.current) return;+ const mesh = instancedMeshRef.current;++ for (let i = 0; i < MAX_RIGID_BODIES; i++) {+ DUMMY.position.copy(FAR_AWAY);+ DUMMY.scale.set(0, 0, 0);+ DUMMY.updateMatrix();+ mesh.setMatrixAt(i, DUMMY.matrix);+ mesh.setColorAt(i, SKELETON_COLORS.hidden);+ }+ mesh.instanceMatrix.needsUpdate = true;+ if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;+ mesh.count = MAX_RIGID_BODIES;+ }, []);++ // Per-frame update: apply transforms for all assigned bones+ useFrame(() => {+ if (!instancedMeshRef.current || !dirtyRef.current) return;+ const mesh = instancedMeshRef.current;+ const poses = rigidBodiesRef.current;++ for (let i = 0; i < nextIndexRef.current; i++) {+ const boneKey = indexToBoneKeyRef.current.get(i);+ if (!boneKey) continue;++ const pose = poses.get(boneKey);+ if (pose) {+ const [px, py, pz] = pose.position;+ const [qw, qx, qy, qz] = pose.orientation;+ const radius = getRigidBodyRadius(boneKey);++ DUMMY.position.set(px, py, pz + Z_OFFSET);++ // Bone quaternion (local +Z = bone direction).+ // Three.js Quaternion constructor: (x, y, z, w).+ // The geometry is already pre-rotated so its axis is +Z,+ // so we apply the bone quaternion directly.+ DUMMY.quaternion.set(qx, qy, qz, qw);++ // Scale: x/y = radius, z = bone length+ DUMMY.scale.set(radius, radius, pose.length);++ mesh.setColorAt(i, getRigidBodyColor(boneKey));+ } else {+ DUMMY.position.copy(FAR_AWAY);+ DUMMY.scale.set(0, 0, 0);+ mesh.setColorAt(i, SKELETON_COLORS.hidden);+ }++ DUMMY.updateMatrix();+ mesh.setMatrixAt(i, DUMMY.matrix);+ }++ mesh.instanceMatrix.needsUpdate = true;+ if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;+ dirtyRef.current = false;+ });++ return (+ <instancedMesh+ ref={instancedMeshRef}+ args={[cylinderGeometry, cylinderMaterial, MAX_RIGID_BODIES]}+ frustumCulled={false}+ />+ );+}diff --git a/freemocap-ui/src/components/viewport3d/SceneEnvironment.tsx b/freemocap-ui/src/components/viewport3d/SceneEnvironment.tsxnew file mode 100644index 00000000..7a234179--- /dev/null+++ b/freemocap-ui/src/components/viewport3d/SceneEnvironment.tsx@@ -0,0 +1,36 @@+import { Grid } from "@react-three/drei";++/** Static scene environment: lighting, ground grid, and axes indicator. */+export function SceneEnvironment() {+ return (+ <>+ <ambientLight intensity={0.6} />+ <directionalLight+ castShadow+ position={[5, 5, 5]}+ intensity={0.5}+ shadow-mapSize={1024}+ />+ {/* Fill light from below to prevent pure-black undersides */}+ <directionalLight+ position={[-3, -2, -3]}+ intensity={0.15}+ />++ <Grid+ renderOrder={-1}+ position={[0, -0.01, 0]}+ infiniteGrid+ cellSize={1}+ cellThickness={0.5}+ sectionSize={3}+ sectionThickness={1}+ //@ts-ignore — drei Grid typing doesn't expose sectionColor as tuple+ sectionColor={[0.25, 0, 0.25]}+ fadeDistance={100}+ />++ <axesHelper />+ </>+ );+}diff --git a/freemocap-ui/src/components/viewport3d/SkeletonRenderer.tsx b/freemocap-ui/src/components/viewport3d/SkeletonRenderer.tsxnew file mode 100644index 00000000..f5b0f899--- /dev/null+++ b/freemocap-ui/src/components/viewport3d/SkeletonRenderer.tsx@@ -0,0 +1,250 @@+import { useEffect, useMemo, useRef } from "react";+import {+ InstancedMesh,+ MeshStandardMaterial,+ SphereGeometry,+ Object3D,+ Vector3,+ BufferGeometry,+ BufferAttribute,+ LineBasicMaterial,+ LineSegments,+} from "three";+import { useFrame } from "@react-three/fiber";+import { useServer } from "@/services";+import { Point3d, PointStyle } from "@/components/viewport3d/viewport3d-types";+import {+ MAX_POINTS,+ MAX_SEGMENTS,+ Z_OFFSET,+ SEGMENT_DEFINITIONS,+ SEGMENT_COLORS,+ getPointStyle,+} from "@/components/viewport3d/skeleton-config";+import { resolvePoint } from "@/components/viewport3d/virtual-points";+import {SKELETON_COLORS} from "@/components/viewport3d/skeleton-colors";++const DUMMY = new Object3D();+const FAR_AWAY = new Vector3(10000, 10000, 10000);++/**+ * Renders the 3D skeleton using an InstancedMesh for landmark points+ * and LineSegments for bone connections. Subscribes directly to the+ * server's tracked-points stream and updates only dirty instances+ * each frame to minimize GPU uploads.+ */+export function SkeletonRenderer() {+ const { subscribeToTrackedPoints } = useServer();+ const instancedMeshRef = useRef<InstancedMesh>(null);+ const lineSegmentsRef = useRef<LineSegments>(null);++ // Mutable refs for frame-loop access without triggering React re-renders+ const trackedPointsRef = useRef<Map<string, Point3d>>(new Map());+ const pointNameToIndexRef = useRef<Map<string, number>>(new Map());+ const indexToPointNameRef = useRef<Map<number, string>>(new Map());+ const cachedStylesRef = useRef<Map<string, PointStyle>>(new Map());+ const nextAvailableIndexRef = useRef<number>(0);+ const dirtyIndicesRef = useRef<Set<number>>(new Set());+ const needsLineUpdateRef = useRef<boolean>(false);++ // Shared geometry: unit sphere scaled per-instance+ const sphereGeometry = useMemo(() => new SphereGeometry(1, 10, 8), []);++ // White base material — per-instance color tints it+ const sphereMaterial = useMemo(() => new MeshStandardMaterial({+ color: '#ffffff',+ roughness: 0.35,+ metalness: 0.5,+ }), []);++ // Vertex-colored line material for skeleton segments+ const lineMaterial = useMemo(() => new LineBasicMaterial({+ vertexColors: true,+ transparent: true,+ opacity: 0.85,+ }), []);++ // Pre-allocated line geometry with position + color buffers+ const lineGeometry = useMemo(() => {+ const geometry = new BufferGeometry();+ const numVerts = MAX_SEGMENTS * 2;+ const positions = new Float32Array(numVerts * 3);+ const colors = new Float32Array(numVerts * 3);++ for (let i = 0; i < MAX_SEGMENTS; i++) {+ const segColor = SEGMENT_COLORS[i];+ for (let v = 0; v < 2; v++) {+ const vi = (i * 2 + v) * 3;+ positions[vi] = 10000;+ positions[vi + 1] = 10000;+ positions[vi + 2] = 10000;+ colors[vi] = segColor.r;+ colors[vi + 1] = segColor.g;+ colors[vi + 2] = segColor.b;+ }+ }++ geometry.setAttribute('position', new BufferAttribute(positions, 3));+ geometry.setAttribute('color', new BufferAttribute(colors, 3));+ return geometry;+ }, []);++ // Assign a stable instance index and cache the point style for a new point name+ const assignIndex = (pointName: string): number => {+ if (nextAvailableIndexRef.current >= MAX_POINTS) {+ throw new Error(`Maximum tracked points (${MAX_POINTS}) exceeded for point "${pointName}"`);+ }+ const index = nextAvailableIndexRef.current++;+ pointNameToIndexRef.current.set(pointName, index);+ indexToPointNameRef.current.set(index, pointName);+ cachedStylesRef.current.set(pointName, getPointStyle(pointName));+ return index;+ };++ // Subscribe to tracked-points stream, mark dirty indices for changed/new/removed points+ useEffect(() => {+ const unsubscribe = subscribeToTrackedPoints((newPoints: Map<string, Point3d>) => {+ const prevPoints = trackedPointsRef.current;+ trackedPointsRef.current = newPoints;+ needsLineUpdateRef.current = true;++ for (const [pointName, point] of newPoints) {+ if (!pointNameToIndexRef.current.has(pointName)) {+ const newIndex = assignIndex(pointName);+ dirtyIndicesRef.current.add(newIndex);+ } else {+ const prevPoint = prevPoints.get(pointName);+ if (!prevPoint ||+ prevPoint.x !== point.x ||+ prevPoint.y !== point.y ||+ prevPoint.z !== point.z) {+ dirtyIndicesRef.current.add(pointNameToIndexRef.current.get(pointName)!);+ }+ }+ }++ // Mark removed points as dirty so they get hidden+ for (const [pointName] of prevPoints) {+ if (!newPoints.has(pointName)) {+ const index = pointNameToIndexRef.current.get(pointName);+ if (index !== undefined) {+ dirtyIndicesRef.current.add(index);+ }+ }+ }+ });++ return unsubscribe;+ }, [subscribeToTrackedPoints]);++ // Initialize all instances as hidden on mount+ useEffect(() => {+ if (!instancedMeshRef.current) return;+ const mesh = instancedMeshRef.current;++ for (let i = 0; i < MAX_POINTS; i++) {+ DUMMY.position.copy(FAR_AWAY);+ DUMMY.scale.set(0, 0, 0);+ DUMMY.updateMatrix();+ mesh.setMatrixAt(i, DUMMY.matrix);+ mesh.setColorAt(i, SKELETON_COLORS.hidden);+ }+ mesh.instanceMatrix.needsUpdate = true;+ if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;+ mesh.count = MAX_POINTS;+ }, []);++ // Per-frame update: apply dirty point transforms and refresh line segment positions+ useFrame(() => {+ // Update dirty point instances+ if (instancedMeshRef.current && dirtyIndicesRef.current.size > 0) {+ const mesh = instancedMeshRef.current;+ const points = trackedPointsRef.current;++ for (const index of dirtyIndicesRef.current) {+ const pointName = indexToPointNameRef.current.get(index);++ if (pointName && points.has(pointName)) {+ const point = points.get(pointName)!;+ const style = cachedStylesRef.current.get(pointName)!;++ DUMMY.position.set(point.x, point.y, point.z + Z_OFFSET);+ DUMMY.scale.set(style.scale, style.scale, style.scale);+ mesh.setColorAt(index, style.color);+ } else {+ DUMMY.position.copy(FAR_AWAY);+ DUMMY.scale.set(0, 0, 0);+ mesh.setColorAt(index, SKELETON_COLORS.hidden);+ }++ DUMMY.updateMatrix();+ mesh.setMatrixAt(index, DUMMY.matrix);+ }++ mesh.instanceMatrix.needsUpdate = true;+ if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;+ dirtyIndicesRef.current.clear();+ }++ // Update line segment vertex positions+ if (lineSegmentsRef.current && needsLineUpdateRef.current) {+ const points = trackedPointsRef.current;+ const positions = lineGeometry.attributes.position.array as Float32Array;+ const colors = lineGeometry.attributes.color.array as Float32Array;+ let segmentIndex = 0;++ for (const segment of Object.values(SEGMENT_DEFINITIONS)) {+ const proximal = resolvePoint(points, segment.proximal);+ const distal = resolvePoint(points, segment.distal);+ const segColor = SEGMENT_COLORS[segmentIndex];+ const baseIdx = segmentIndex * 6;++ if (proximal && distal) {+ positions[baseIdx] = proximal.x;+ positions[baseIdx + 1] = proximal.y;+ positions[baseIdx + 2] = proximal.z + Z_OFFSET;++ positions[baseIdx + 3] = distal.x;+ positions[baseIdx + 4] = distal.y;+ positions[baseIdx + 5] = distal.z + Z_OFFSET;++ colors[baseIdx] = segColor.r;+ colors[baseIdx + 1] = segColor.g;+ colors[baseIdx + 2] = segColor.b;+ colors[baseIdx + 3] = segColor.r;+ colors[baseIdx + 4] = segColor.g;+ colors[baseIdx + 5] = segColor.b;+ } else {+ for (let i = 0; i < 6; i++) {+ positions[baseIdx + i] = 10000;+ }+ }++ segmentIndex++;+ }++ lineGeometry.attributes.position.needsUpdate = true;+ lineGeometry.attributes.color.needsUpdate = true;+ needsLineUpdateRef.current = false;+ }+ });++ return (+ <>+ {/* Per-instance colored landmark points */}+ <instancedMesh+ ref={instancedMeshRef}+ args={[sphereGeometry, sphereMaterial, MAX_POINTS]}+ frustumCulled={false}+ />++ {/* Vertex-colored skeleton segments */}+ <lineSegments+ ref={lineSegmentsRef}+ geometry={lineGeometry}+ material={lineMaterial}+ frustumCulled={false}+ />+ </>+ );+}diff --git a/freemocap-ui/src/components/viewport3d/ThreeJsCanvas.tsx b/freemocap-ui/src/components/viewport3d/ThreeJsCanvas.tsxindex 27061efa..90f5ebae 100644--- a/freemocap-ui/src/components/viewport3d/ThreeJsCanvas.tsx+++ b/freemocap-ui/src/components/viewport3d/ThreeJsCanvas.tsx@@ -1,23 +1,71 @@-import {Canvas} from "@react-three/fiber";-import {ThreeJsScene} from "@/components/viewport3d/ThreeJsScene";-import {Box} from "@mui/material";-+import { useCallback, useEffect, useRef } from "react";+import { Canvas } from "@react-three/fiber";+import { Box, IconButton, Tooltip } from "@mui/material";+import CenterFocusStrongIcon from "@mui/icons-material/CenterFocusStrong";+import type CameraControlsImpl from "camera-controls";+import { ThreeJsScene } from "@/components/viewport3d/ThreeJsScene";+import { fitCameraToSkeleton } from "@/components/viewport3d/fit-camera";+import { useServer } from "@/services";export function ThreeJsCanvas() {+ const cameraControlsRef = useRef<CameraControlsImpl>(null!);+ const containerRef = useRef<HTMLDivElement>(null);+ const { getLatestTrackedPoints } = useServer();++ const handleFitToSkeleton = useCallback(() => {+ fitCameraToSkeleton(cameraControlsRef.current, getLatestTrackedPoints());+ }, [getLatestTrackedPoints]);++ // Press "F" while the viewport container is focused to fit camera to skeleton+ useEffect(() => {+ const container = containerRef.current;+ if (!container) return;++ const handleKeyDown = (e: KeyboardEvent) => {+ if (e.key === "f" || e.key === "F") {+ e.preventDefault();+ handleFitToSkeleton();+ }+ };++ container.addEventListener("keydown", handleKeyDown);+ return () => container.removeEventListener("keydown", handleKeyDown);+ }, [handleFitToSkeleton]);return (- <Box sx={{width: '100%',- height: '100%',- }}>+ <Box+ ref={containerRef}+ tabIndex={0}+ sx={{+ width: '100%',+ height: '100%',+ position: 'relative',+ outline: 'none',+ }}+ ><Canvasshadows- camera={{position: [5, 5, 5], fov: 75}}+ camera={{ position: [5, 5, 5], fov: 75 }}>- <ThreeJsScene/>+ <ThreeJsScene cameraControlsRef={cameraControlsRef} /></Canvas>- </Box>- );-}--+ <Tooltip title="Fit camera to skeleton (F)" placement="left">+ <IconButton+ onClick={handleFitToSkeleton}+ size="small"+ sx={{+ position: 'absolute',+ bottom: 16,+ right: 16,+ bgcolor: 'background.paper',+ boxShadow: 2,+ '&:hover': { bgcolor: 'action.hover' },+ }}+ >+ <CenterFocusStrongIcon fontSize="small" />+ </IconButton>+ </Tooltip>+ </Box>+ );+}\ No newline at end of filediff --git a/freemocap-ui/src/components/viewport3d/ThreeJsScene.tsx b/freemocap-ui/src/components/viewport3d/ThreeJsScene.tsxindex f7650b28..3f9f79d6 100644--- a/freemocap-ui/src/components/viewport3d/ThreeJsScene.tsx+++ b/freemocap-ui/src/components/viewport3d/ThreeJsScene.tsx@@ -1,360 +1,22 @@-import {useEffect, useMemo, useRef} from "react";-import {- CameraHelper,- InstancedMesh,- MeshStandardMaterial,- PerspectiveCamera,- SphereGeometry,- Object3D,- Matrix4,- Vector3,- BufferGeometry,- BufferAttribute,- LineBasicMaterial,- LineSegments-} from "three";-import {extend, useFrame} from "@react-three/fiber";-import {CameraControls, Grid} from "@react-three/drei";-import {useServer} from "@/services";--extend({CameraHelper});--const MAX_POINTS = 1000; // Pre-allocate for max expected points-const POINT_SCALE = 1; // Scale points down since they're in meters-const DUMMY = new Object3D(); // Reusable dummy object for matrix updates--interface Point3d {- x: number;- y: number;- z: number;+import { RefObject } from "react";+import { CameraControls } from "@react-three/drei";+import type CameraControlsImpl from "camera-controls";+import { SceneEnvironment } from "@/components/viewport3d/SceneEnvironment";+import { SkeletonRenderer } from "@/components/viewport3d/SkeletonRenderer";+import { RigidBodyRenderer } from "@/components/viewport3d/RigidBodyRenderer";++interface ThreeJsSceneProps {+ cameraControlsRef: RefObject<CameraControlsImpl>;}-// Segment definitions with virtual points that need to be calculated-const SEGMENT_DEFINITIONS: Record<string, {proximal: string, distal: string}> = {- head: { proximal: "body.left_ear", distal: "body.right_ear" },- neck: { proximal: "head_center", distal: "neck_center" },- spine: { proximal: "neck_center", distal: "hips_center" },- right_shoulder: { proximal: "neck_center", distal: "body.right_shoulder" },- left_shoulder: { proximal: "neck_center", distal: "body.left_shoulder" },- right_upper_arm: { proximal: "body.right_shoulder", distal: "body.right_elbow" },- left_upper_arm: { proximal: "body.left_shoulder", distal: "body.left_elbow" },- right_forearm: { proximal: "body.right_elbow", distal: "body.right_wrist" },- left_forearm: { proximal: "body.left_elbow", distal: "body.left_wrist" },- right_hand: { proximal: "body.right_wrist", distal: "body.right_index" },- left_hand: { proximal: "body.left_wrist", distal: "body.left_index" },- right_pelvis: { proximal: "hips_center", distal: "body.right_hip" },- left_pelvis: { proximal: "hips_center", distal: "body.left_hip" },- right_thigh: { proximal: "body.right_hip", distal: "body.right_knee" },- left_thigh: { proximal: "body.left_hip", distal: "body.left_knee" },- right_shank: { proximal: "body.right_knee", distal: "body.right_ankle" },- left_shank: { proximal: "body.left_knee", distal: "body.left_ankle" },- right_foot: { proximal: "body.right_ankle", distal: "body.right_foot_index" },- left_foot: { proximal: "body.left_ankle", distal: "body.left_foot_index" },- right_heel: { proximal: "body.right_ankle", distal: "body.right_heel" },- left_heel: { proximal: "body.left_ankle", distal: "body.left_heel" },- right_foot_bottom: { proximal: "body.right_heel", distal: "body.right_foot_index" },- left_foot_bottom: { proximal: "body.left_heel", distal: "body.left_foot_index" },-};--const MAX_SEGMENTS = Object.keys(SEGMENT_DEFINITIONS).length;--export function ThreeJsScene() {- const { connectedCameraIds, subscribeToTrackedPoints } = useServer();- const instancedMeshRef = useRef<InstancedMesh>(null);- const lineSegmentsRef = useRef<LineSegments>(null);- const cameraRefs = useRef<PerspectiveCamera[]>([]);-- // Performance-critical: Direct refs to avoid React re-renders- const trackedPointsRef = useRef<Map<string, Point3d>>(new Map());- const pointNameToIndexRef = useRef<Map<string, number>>(new Map());- const nextAvailableIndexRef = useRef<number>(0);- const dirtyIndicesRef = useRef<Set<number>>(new Set());- const needsLineUpdate = useRef<boolean>(false);-- // Pre-create geometry and material once- const sphereGeometry = useMemo(() => new SphereGeometry(0.4, 8, 6), []); // Bigger spheres- const sphereMaterial = useMemo(() => new MeshStandardMaterial({- color: '#00ff66', // Brighter color for visibility- roughness: 0.4,- metalness: 0.6,- emissive: '#00ff66',- emissiveIntensity: 0.2- }), []);-- // Create line material- const lineMaterial = useMemo(() => new LineBasicMaterial({- color: '#ffffff',- linewidth: 2,- transparent: true,- opacity: 0.8- }), []);-- // Create line geometry with pre-allocated buffer- const lineGeometry = useMemo(() => {- const geometry = new BufferGeometry();- // Each segment needs 2 vertices (6 floats)- const positions = new Float32Array(MAX_SEGMENTS * 2 * 3);- // Initialize far away- for (let i = 0; i < positions.length; i++) {- positions[i] = 10000;- }- geometry.setAttribute('position', new BufferAttribute(positions, 3));- return geometry;- }, []);-- // Calculate positions for cameras in a grid- const cameraPositions = useMemo(() => {- const numCameras = connectedCameraIds.length;- if (numCameras === 0) return [];-- const maxRowsColumns = Math.ceil(Math.sqrt(numCameras));- const verticalSpacing = 2.5;- const horizontalSpacing = 2.2;- const verticalOffset = 1;-- return connectedCameraIds.map((_, index) => {- const columnIndex = index % maxRowsColumns;- const rowIndex = Math.floor(index / maxRowsColumns);-- const xPosition = columnIndex * horizontalSpacing - (maxRowsColumns * horizontalSpacing) / 2;- const yPosition = rowIndex * verticalSpacing + verticalOffset;- const zPosition = 0;-- return [xPosition, yPosition, zPosition] as [number, number, number];- });- }, [connectedCameraIds]);-- // Helper function to calculate virtual points- const calculateVirtualPoint = (points: Map<string, Point3d>, virtualName: string): Point3d | null => {- switch(virtualName) {- case "head_center": {- const leftEar = points.get("body.left_ear");- const rightEar = points.get("body.right_ear");- if (!leftEar || !rightEar) return null;- return {- x: (leftEar.x + rightEar.x) / 2,- y: (leftEar.y + rightEar.y) / 2,- z: (leftEar.z + rightEar.z) / 2- };- }- case "neck_center": {- const leftShoulder = points.get("body.left_shoulder");- const rightShoulder = points.get("body.right_shoulder");- if (!leftShoulder || !rightShoulder) return null;- return {- x: (leftShoulder.x + rightShoulder.x) / 2,- y: (leftShoulder.y + rightShoulder.y) / 2,- z: (leftShoulder.z + rightShoulder.z) / 2- };- }- case "hips_center": {- const leftHip = points.get("body.left_hip");- const rightHip = points.get("body.right_hip");- if (!leftHip || !rightHip) return null;- return {- x: (leftHip.x + rightHip.x) / 2,- y: (leftHip.y + rightHip.y) / 2,- z: (leftHip.z + rightHip.z) / 2- };- }- default:- return points.get(virtualName) || null;- }- };-- // Subscribe to tracked points updates- useEffect(() => {- const unsubscribe = subscribeToTrackedPoints((newPoints: Map<string, Point3d>) => {- // Only update the ref and mark dirty indices - no React state updates!- const prevPoints = trackedPointsRef.current;- trackedPointsRef.current = newPoints;- needsLineUpdate.current = true; // Mark lines for update-- // Find new points that need indices assigned- for (const [pointName, point] of newPoints) {- if (!pointNameToIndexRef.current.has(pointName)) {- // New point detected - assign it an index- if (nextAvailableIndexRef.current >= MAX_POINTS) {- console.error(`Maximum points (${MAX_POINTS}) exceeded!`);- continue;- }- const newIndex = nextAvailableIndexRef.current++;- pointNameToIndexRef.current.set(pointName, newIndex);- dirtyIndicesRef.current.add(newIndex);- } else {- // Existing point - check if position changed- const prevPoint = prevPoints.get(pointName);- if (!prevPoint ||- prevPoint.x !== point.x ||- prevPoint.y !== point.y ||- prevPoint.z !== point.z) {- const index = pointNameToIndexRef.current.get(pointName)!;- dirtyIndicesRef.current.add(index);- }- }- }-- // Mark removed points as dirty (move them far away to hide)- for (const [pointName] of prevPoints) {- if (!newPoints.has(pointName)) {- const index = pointNameToIndexRef.current.get(pointName);- if (index !== undefined) {- dirtyIndicesRef.current.add(index);- }- }- }- });-- return unsubscribe;- }, [subscribeToTrackedPoints]);-- // Initialize instance matrices on mount- useEffect(() => {- if (!instancedMeshRef.current) return;-- // Hide all instances initially by moving them far away- const farAway = new Vector3(10000, 10000, 10000);- for (let i = 0; i < MAX_POINTS; i++) {- DUMMY.position.copy(farAway);- DUMMY.scale.set(POINT_SCALE, POINT_SCALE, POINT_SCALE);- DUMMY.updateMatrix();- instancedMeshRef.current.setMatrixAt(i, DUMMY.matrix);- }- instancedMeshRef.current.instanceMatrix.needsUpdate = true;- instancedMeshRef.current.count = MAX_POINTS;- }, []);-- // Update matrices in the render loop for maximum performance- useFrame(() => {- // Update camera orientations- cameraRefs.current.forEach(camera => {- if (camera) {- camera.lookAt(0, 0, 0);- }- });-- const scale = 1 // Adjust this to fit your scene- const farAway = new Vector3(10000, 10000, 10000);-- // Update points if we have dirty indices- if (instancedMeshRef.current && dirtyIndicesRef.current.size > 0) {- const mesh = instancedMeshRef.current;- const points = trackedPointsRef.current;- const nameToIndex = pointNameToIndexRef.current;-- // Process only dirty indices- for (const index of dirtyIndicesRef.current) {- // Find the point name for this index- let pointName: string | null = null;- for (const [name, idx] of nameToIndex) {- if (idx === index) {- pointName = name;- break;- }- }-- if (pointName && points.has(pointName)) {- // Update position for visible point- const point = points.get(pointName)!;- DUMMY.position.set(- point.x * scale,- point.y * scale,- (point.z - 15) * scale // Center around z=15 then scale- );- DUMMY.scale.set(POINT_SCALE, POINT_SCALE, POINT_SCALE);- } else {- // Hide removed/missing points- DUMMY.position.copy(farAway);- DUMMY.scale.set(0, 0, 0);- }-- DUMMY.updateMatrix();- mesh.setMatrixAt(index, DUMMY.matrix);- }-- // Only update the GPU buffer if we made changes- if (dirtyIndicesRef.current.size > 0) {- mesh.instanceMatrix.needsUpdate = true;- dirtyIndicesRef.current.clear();- }- }-- // Update line segments- if (lineSegmentsRef.current && needsLineUpdate.current) {- const points = trackedPointsRef.current;- const positions = lineGeometry.attributes.position.array as Float32Array;- let segmentIndex = 0;-- for (const [segmentName, segment] of Object.entries(SEGMENT_DEFINITIONS)) {- const proximalPoint = calculateVirtualPoint(points, segment.proximal);- const distalPoint = calculateVirtualPoint(points, segment.distal);-- if (proximalPoint && distalPoint) {- // Set proximal vertex- positions[segmentIndex * 6] = proximalPoint.x * scale;- positions[segmentIndex * 6 + 1] = proximalPoint.y * scale;- positions[segmentIndex * 6 + 2] = (proximalPoint.z - 15) * scale;-- // Set distal vertex- positions[segmentIndex * 6 + 3] = distalPoint.x * scale;- positions[segmentIndex * 6 + 4] = distalPoint.y * scale;- positions[segmentIndex * 6 + 5] = (distalPoint.z - 15) * scale;- } else {- // Hide segment if points not available- for (let i = 0; i < 6; i++) {- positions[segmentIndex * 6 + i] = 10000;- }- }-- segmentIndex++;- }-- lineGeometry.attributes.position.needsUpdate = true;- needsLineUpdate.current = false;- }- });-+/** Top-level scene graph: camera controls, environment, and skeleton visualization. */+export function ThreeJsScene({ cameraControlsRef }: ThreeJsSceneProps) {return (<>- <CameraControls makeDefault/>-- <ambientLight intensity={0.5}/>- <directionalLight- castShadow- position={[5, 5, 5]}- intensity={0.5}- shadow-mapSize={1024}- />-- <Grid- renderOrder={-1}- position={[0, -0.01, 0]}- infiniteGrid- cellSize={1}- cellThickness={0.5}- sectionSize={3}- sectionThickness={1}- //@ts-ignore- sectionColor={[0.25, 0, 0.25]}- fadeDistance={100}- />-- <axesHelper/>-- {/* Single InstancedMesh for all tracked points */}- <instancedMesh- ref={instancedMeshRef}- args={[sphereGeometry, sphereMaterial, MAX_POINTS]}- frustumCulled={false}- />-- {/* Line segments for body connections */}- <lineSegments- ref={lineSegmentsRef}- geometry={lineGeometry}- material={lineMaterial}- frustumCulled={false}- />+ <CameraControls ref={cameraControlsRef} makeDefault />+ <SceneEnvironment />+ <SkeletonRenderer />+ <RigidBodyRenderer /></>);-}\ No newline at end of file+}diff --git a/freemocap-ui/src/components/viewport3d/VMCPanel.tsx b/freemocap-ui/src/components/viewport3d/VMCPanel.tsxnew file mode 100644index 00000000..7c1c07fb--- /dev/null+++ b/freemocap-ui/src/components/viewport3d/VMCPanel.tsx@@ -0,0 +1,129 @@+import React, { useCallback } from "react";+import {+ Box,+ IconButton,+ Stack,+ Switch,+ TextField,+ Tooltip,+ Typography,+ useTheme,+} from "@mui/material";+import CastConnectedIcon from "@mui/icons-material/CastConnected";+import { useAppSelector } from "@/store/hooks";+import { selectServerSettings } from "@/store/slices/settings/settings-selectors";+import { useServer } from "@/services";++/**+ * Compact VMC output controls. Shows a toggle to enable/disable VMC+ * broadcasting and a port field. Patches are sent directly via the+ * WebSocket settings/patch protocol.+ */+export const VMCPanel: React.FC = () => {+ const theme = useTheme();+ const { send, isConnected } = useServer();+ const settings = useAppSelector(selectServerSettings);++ const vmcEnabled = settings?.vmc?.enabled ?? false;+ const vmcHost = settings?.vmc?.host ?? "127.0.0.1";+ const vmcPort = settings?.vmc?.port ?? 39539;++ const patchVMC = useCallback(+ (patch: Record<string, unknown>) => {+ send({ message_type: "settings/patch", patch: { vmc: patch } });+ },+ [send],+ );++ const handleToggle = useCallback(() => {+ patchVMC({ enabled: !vmcEnabled });+ }, [patchVMC, vmcEnabled]);++ const handlePortChange = useCallback(+ (e: React.ChangeEvent<HTMLInputElement>) => {+ const val = parseInt(e.target.value, 10);+ if (!isNaN(val) && val > 0 && val <= 65535) {+ patchVMC({ port: val });+ }+ },+ [patchVMC],+ );++ const handleHostChange = useCallback(+ (e: React.ChangeEvent<HTMLInputElement>) => {+ const val = e.target.value.trim();+ if (val.length > 0) {+ patchVMC({ host: val });+ }+ },+ [patchVMC],+ );++ return (+ <Box+ sx={{+ position: "absolute",+ bottom: 16,+ right: 16,+ zIndex: 10,+ backgroundColor: theme.palette.background.paper,+ borderRadius: 2,+ px: 2,+ py: 1.5,+ boxShadow: 3,+ minWidth: 220,+ opacity: 0.92,+ }}+ >+ <Stack spacing={1}>+ <Stack direction="row" alignItems="center" spacing={1}>+ <CastConnectedIcon+ fontSize="small"+ sx={{ color: vmcEnabled ? theme.palette.success.main : theme.palette.text.disabled }}+ />+ <Typography variant="subtitle2" sx={{ flexGrow: 1, fontWeight: 600 }}>+ VMC Output+ </Typography>+ <Tooltip title={vmcEnabled ? "Disable VMC streaming" : "Enable VMC streaming"} arrow>+ <Switch+ size="small"+ checked={vmcEnabled}+ onChange={handleToggle}+ disabled={!isConnected}+ />+ </Tooltip>+ </Stack>++ {vmcEnabled && (+ <Stack direction="row" spacing={1}>+ <Tooltip title="Target host (IP address)" arrow placement="bottom">+ <TextField+ label="Host"+ size="small"+ value={vmcHost}+ onChange={handleHostChange}+ disabled={!isConnected}+ sx={{ flex: 2 }}+ inputProps={{ style: { fontSize: 12 } }}+ InputLabelProps={{ style: { fontSize: 12 } }}+ />+ </Tooltip>+ <Tooltip title="UDP port (default 39539)" arrow placement="bottom">+ <TextField+ label="Port"+ size="small"+ type="number"+ value={vmcPort}+ onChange={handlePortChange}+ disabled={!isConnected}+ sx={{ flex: 1 }}+ inputProps={{ min: 1, max: 65535, style: { fontSize: 12 } }}+ InputLabelProps={{ style: { fontSize: 12 } }}+ />+ </Tooltip>+ </Stack>+ )}+ </Stack>+ </Box>+ );+};diff --git a/freemocap-ui/src/components/viewport3d/Viewport3dPage.tsx b/freemocap-ui/src/components/viewport3d/Viewport3dPage.tsxnew file mode 100644index 00000000..b5964d1e--- /dev/null+++ b/freemocap-ui/src/components/viewport3d/Viewport3dPage.tsx@@ -0,0 +1,13 @@+import {Box} from "@mui/material";+import React from "react";+import {ThreeJsCanvas} from "@/components/viewport3d/ThreeJsCanvas";+import {VMCPanel} from "@/components/viewport3d/VMCPanel";++export const Viewport3dPage = () => {+ return (+ <Box sx={{width: '100%', height: '100%', position: 'relative'}}>+ <ThreeJsCanvas/>+ <VMCPanel/>+ </Box>+ );+}diff --git a/freemocap-ui/src/components/viewport3d/face-contours.ts b/freemocap-ui/src/components/viewport3d/face-contours.tsnew file mode 100644index 00000000..abb43873--- /dev/null+++ b/freemocap-ui/src/components/viewport3d/face-contours.ts@@ -0,0 +1,139 @@+import { Color } from "three";+import {SKELETON_COLORS} from "@/components/viewport3d/skeleton-colors";++/**+ * MediaPipe face mesh contour connections, matching the Python tracker's+ * naming convention: `face.{group}_{raw_mediapipe_index}`.+ *+ * Connection pairs come from mediapipe.python.solutions.face_mesh_connections:+ * FACEMESH_LIPS, FACEMESH_LEFT_EYE, FACEMESH_RIGHT_EYE,+ * FACEMESH_LEFT_EYEBROW, FACEMESH_RIGHT_EYEBROW, FACEMESH_FACE_OVAL,+ * FACEMESH_LEFT_IRIS, FACEMESH_RIGHT_IRIS+ */++interface FaceContourGroup {+ prefix: string;+ connections: [number, number][];+ color: Color;+}++const FACE_CONTOUR_GROUPS: FaceContourGroup[] = [+ {+ prefix: "face.lips",+ color: SKELETON_COLORS.face,+ connections: [+ // Outer lip upper+ [61, 146], [146, 91], [91, 181], [181, 84], [84, 17],+ [17, 314], [314, 405], [405, 321], [321, 375], [375, 291],+ // Outer lip lower+ [61, 185], [185, 40], [40, 39], [39, 37], [37, 0],+ [0, 267], [267, 269], [269, 270], [270, 409], [409, 291],+ // Inner lip upper+ [78, 95], [95, 88], [88, 178], [178, 87], [87, 14],+ [14, 317], [317, 402], [402, 318], [318, 324], [324, 308],+ // Inner lip lower+ [78, 191], [191, 80], [80, 81], [81, 82], [82, 13],+ [13, 312], [312, 311], [311, 310], [310, 415], [415, 308],+ ],+ },+ {+ prefix: "face.left_eye",+ color: SKELETON_COLORS.face,+ connections: [+ [263, 249], [249, 390], [390, 373], [373, 374], [374, 380],+ [380, 381], [381, 382], [382, 362],+ [263, 466], [466, 388], [388, 387], [387, 386], [386, 385],+ [385, 384], [384, 398], [398, 362],+ ],+ },+ {+ prefix: "face.right_eye",+ color: SKELETON_COLORS.face,+ connections: [+ [33, 7], [7, 163], [163, 144], [144, 145], [145, 153],+ [153, 154], [154, 155], [155, 133],+ [33, 246], [246, 161], [161, 160], [160, 159], [159, 158],+ [158, 157], [157, 173], [173, 133],+ ],+ },+ {+ prefix: "face.left_eyebrow",+ color: SKELETON_COLORS.face,+ connections: [+ [276, 283], [283, 282], [282, 295], [295, 285],+ [300, 293], [293, 334], [334, 296], [296, 336],+ ],+ },+ {+ prefix: "face.right_eyebrow",+ color: SKELETON_COLORS.face,+ connections: [+ [46, 53], [53, 52], [52, 65], [65, 55],+ [70, 63], [63, 105], [105, 66], [66, 107],+ ],+ },+ {+ prefix: "face.face_oval",+ color: SKELETON_COLORS.face,+ connections: [+ [10, 338], [338, 297], [297, 332], [332, 284], [284, 251],+ [251, 389], [389, 356], [356, 454], [454, 323], [323, 361],+ [361, 288], [288, 397], [397, 365], [365, 379], [379, 378],+ [378, 400], [400, 377], [377, 152], [152, 148], [148, 176],+ [176, 149], [149, 150], [150, 136], [136, 172], [172, 58],+ [58, 132], [132, 93], [93, 234], [234, 127], [127, 162],+ [162, 21], [21, 54], [54, 103], [103, 67], [67, 109],+ [109, 10],+ ],+ },+ {+ prefix: "face.left_iris",+ color: SKELETON_COLORS.face,+ connections: [+ [474, 475], [475, 476], [476, 477], [477, 474],+ ],+ },+ {+ prefix: "face.right_iris",+ color: SKELETON_COLORS.face,+ connections: [+ [469, 470], [470, 471], [471, 472], [472, 469],+ ],+ },+];++/**+ * Build segment definitions for all face contour groups.+ * Each connection (a, b) becomes a segment from `{prefix}_{a}` to `{prefix}_{b}`.+ */+export function buildFaceContourSegments(): Record<string, { proximal: string; distal: string }> {+ const segments: Record<string, { proximal: string; distal: string }> = {};++ for (const group of FACE_CONTOUR_GROUPS) {+ for (let i = 0; i < group.connections.length; i++) {+ const [a, b] = group.connections[i];+ segments[`${group.prefix}_seg_${i}`] = {+ proximal: `${group.prefix}_${a}`,+ distal: `${group.prefix}_${b}`,+ };+ }+ }++ return segments;+}++/**+ * Build the color array for all face contour segments, in the same+ * order as buildFaceContourSegments produces entries.+ */+export function buildFaceContourColors(): Color[] {+ const colors: Color[] = [];++ for (const group of FACE_CONTOUR_GROUPS) {+ for (let _i = 0; _i < group.connections.length; _i++) {+ colors.push(group.color);+ }+ }++ return colors;+}diff --git a/freemocap-ui/src/components/viewport3d/fit-camera.ts b/freemocap-ui/src/components/viewport3d/fit-camera.tsnew file mode 100644index 00000000..8bea125a--- /dev/null+++ b/freemocap-ui/src/components/viewport3d/fit-camera.ts@@ -0,0 +1,26 @@+import { Box3, Vector3 } from "three";+import type CameraControlsImpl from "camera-controls";+import { Z_OFFSET } from "@/components/viewport3d/skeleton-config";+import {Point3d} from "@/services";++const PADDING = 0.5;++/**+ * Compute a bounding box around all tracked points and smoothly+ * transition the camera to frame it. No-ops if there are no points+ * or CameraControls isn't ready.+ */+export function fitCameraToSkeleton(+ controls: CameraControlsImpl | null,+ points: Map<string, Point3d>,+): void {+ if (!controls || points.size === 0) return;++ const box = new Box3();+ for (const point of points.values()) {+ box.expandByPoint(new Vector3(point.x, point.y, point.z + Z_OFFSET));+ }+ box.expandByScalar(PADDING);++ controls.fitToBox(box, true);+}diff --git a/freemocap-ui/src/components/viewport3d/skeleton-colors.ts b/freemocap-ui/src/components/viewport3d/skeleton-colors.tsnew file mode 100644index 00000000..06c29589--- /dev/null+++ b/freemocap-ui/src/components/viewport3d/skeleton-colors.ts@@ -0,0 +1,11 @@+import { Color } from "three";++export const SKELETON_COLORS = {+ left: new Color('#4488FF'),+ right: new Color('#FF4444'),+ center: new Color('#00AA00'),+ leftHand: new Color('#00FFFF'),+ rightHand: new Color('#FF00FF'),+ face: new Color('#FFD700'),+ hidden: new Color('#000000'),+} as const;diff --git a/freemocap-ui/src/components/viewport3d/skeleton-config.ts b/freemocap-ui/src/components/viewport3d/skeleton-config.tsnew file mode 100644index 00000000..d69fb3f3--- /dev/null+++ b/freemocap-ui/src/components/viewport3d/skeleton-config.ts@@ -0,0 +1,168 @@+import { Color } from "three";+import { PointStyle } from "@/components/viewport3d/viewport3d-types";+import { buildFaceContourSegments, buildFaceContourColors } from "@/components/viewport3d/face-contours";+import {SKELETON_COLORS} from "@/components/viewport3d/skeleton-colors";++// Maximum tracked points the instanced mesh can hold+export const MAX_POINTS = 1000;++// Z-axis offset applied to all tracked points to center the skeleton in view+export const Z_OFFSET = -15;++// --- Color palette (matches 2D overlay) ---++++// --- Point styling: color + sphere scale per body part ---++export function getPointStyle(name: string): PointStyle {+ // Face landmarks — near-invisible dots, contour lines carry the visual+ if (name.startsWith('face.')) {+ return { color: SKELETON_COLORS.face, scale: 0.02 };+ }++ if (name.startsWith('left_hand.')) {+ return { color: SKELETON_COLORS.leftHand, scale: 0.075 };+ }+ if (name.startsWith('right_hand.')) {+ return { color: SKELETON_COLORS.rightHand, scale: 0.075 };+ }++ // Body — eyes, ears, mouth are small+ if (name.includes('eye') || name.includes('ear') || name.includes('mouth')) {+ const side = name.includes('left') ? SKELETON_COLORS.left+ : name.includes('right') ? SKELETON_COLORS.right+ : SKELETON_COLORS.center;+ return { color: side, scale: 0.125 };+ }++ // Body — fingers at wrist level+ if (name.includes('pinky') || name.includes('index') || name.includes('thumb')) {+ const side = name.includes('left') ? SKELETON_COLORS.left : SKELETON_COLORS.right;+ return { color: side, scale: 0.05 };+ }++ // Body — feet+ if (name.includes('heel') || name.includes('foot_index') || name.includes('ankle')) {+ const side = name.includes('left') ? SKELETON_COLORS.left : SKELETON_COLORS.right;+ return { color: side, scale: 0.3 };+ }++ // Body — major joints (shoulder, elbow, wrist, hip, knee)+ if (name.includes('left')) {+ return { color: SKELETON_COLORS.left, scale: 0.2 };+ }+ if (name.includes('right')) {+ return { color: SKELETON_COLORS.right, scale: 0.2 };+ }++ // Center (nose, etc.)+ return { color: SKELETON_COLORS.center, scale: 0.15 };+}++// --- Segment color determined by segment name ---++function getSegmentColor(segmentName: string): Color {+ if (segmentName.startsWith('left_hand_')) return SKELETON_COLORS.leftHand;+ if (segmentName.startsWith('right_hand_')) return SKELETON_COLORS.rightHand;+ if (segmentName.startsWith('left')) return SKELETON_COLORS.left;+ if (segmentName.startsWith('right')) return SKELETON_COLORS.right;+ return SKELETON_COLORS.center;+}++// --- Hand connection template (MediaPipe hand landmark topology) ---++const HAND_CONNECTIONS: [string, string][] = [+ // Thumb+ ['wrist', 'thumb_cmc'],+ ['thumb_cmc', 'thumb_mcp'],+ ['thumb_mcp', 'thumb_ip'],+ ['thumb_ip', 'thumb_tip'],+ // Index finger+ ['wrist', 'index_finger_mcp'],+ ['index_finger_mcp', 'index_finger_pip'],+ ['index_finger_pip', 'index_finger_dip'],+ ['index_finger_dip', 'index_finger_tip'],+ // Middle finger+ ['wrist', 'middle_finger_mcp'],+ ['middle_finger_mcp', 'middle_finger_pip'],+ ['middle_finger_pip', 'middle_finger_dip'],+ ['middle_finger_dip', 'middle_finger_tip'],+ // Ring finger+ ['wrist', 'ring_finger_mcp'],+ ['ring_finger_mcp', 'ring_finger_pip'],+ ['ring_finger_pip', 'ring_finger_dip'],+ ['ring_finger_dip', 'ring_finger_tip'],+ // Pinky+ ['wrist', 'pinky_mcp'],+ ['pinky_mcp', 'pinky_pip'],+ ['pinky_pip', 'pinky_dip'],+ ['pinky_dip', 'pinky_tip'],+ // Palm+ ['index_finger_mcp', 'middle_finger_mcp'],+ ['middle_finger_mcp', 'ring_finger_mcp'],+ ['ring_finger_mcp', 'pinky_mcp'],+];++function buildHandSegments(handPrefix: string): Record<string, { proximal: string; distal: string }> {+ const segments: Record<string, { proximal: string; distal: string }> = {};+ HAND_CONNECTIONS.forEach(([proximal, distal], i) => {+ segments[`${handPrefix}_seg_${i}`] = {+ proximal: `${handPrefix}.${proximal}`,+ distal: `${handPrefix}.${distal}`,+ };+ });+ return segments;+}++// --- Body + hand segment definitions ---++const BODY_HAND_SEGMENTS: Record<string, { proximal: string; distal: string }> = {+ // Body+ head: { proximal: "body.left_ear", distal: "body.right_ear" },+ neck: { proximal: "head_center", distal: "neck_center" },+ spine: { proximal: "neck_center", distal: "hips_center" },+ right_shoulder: { proximal: "neck_center", distal: "body.right_shoulder" },+ left_shoulder: { proximal: "neck_center", distal: "body.left_shoulder" },+ right_upper_arm: { proximal: "body.right_shoulder", distal: "body.right_elbow" },+ left_upper_arm: { proximal: "body.left_shoulder", distal: "body.left_elbow" },+ right_forearm: { proximal: "body.right_elbow", distal: "body.right_wrist" },+ left_forearm: { proximal: "body.left_elbow", distal: "body.left_wrist" },+ right_hand_body: { proximal: "body.right_wrist", distal: "body.right_index" },+ left_hand_body: { proximal: "body.left_wrist", distal: "body.left_index" },+ right_pelvis: { proximal: "hips_center", distal: "body.right_hip" },+ left_pelvis: { proximal: "hips_center", distal: "body.left_hip" },+ right_thigh: { proximal: "body.right_hip", distal: "body.right_knee" },+ left_thigh: { proximal: "body.left_hip", distal: "body.left_knee" },+ right_shank: { proximal: "body.right_knee", distal: "body.right_ankle" },+ left_shank: { proximal: "body.left_knee", distal: "body.left_ankle" },+ right_foot: { proximal: "body.right_ankle", distal: "body.right_foot_index" },+ left_foot: { proximal: "body.left_ankle", distal: "body.left_foot_index" },+ right_heel: { proximal: "body.right_ankle", distal: "body.right_heel" },+ left_heel: { proximal: "body.left_ankle", distal: "body.left_heel" },+ right_foot_bottom: { proximal: "body.right_heel", distal: "body.right_foot_index" },+ left_foot_bottom: { proximal: "body.left_heel", distal: "body.left_foot_index" },+ // Hands+ ...buildHandSegments('right_hand'),+ ...buildHandSegments('left_hand'),+};++// Pre-compute body+hand segment colors+const BODY_HAND_COLORS: Color[] = Object.keys(BODY_HAND_SEGMENTS).map(getSegmentColor);++// --- Face contour segments ---++const FACE_SEGMENTS = buildFaceContourSegments();+const FACE_COLORS = buildFaceContourColors();++// --- Combined: body + hands + face contours ---++export const SEGMENT_DEFINITIONS: Record<string, { proximal: string; distal: string }> = {+ ...BODY_HAND_SEGMENTS,+ ...FACE_SEGMENTS,+};++export const MAX_SEGMENTS = Object.keys(SEGMENT_DEFINITIONS).length;++// Colors in matching order: body+hand first, then face contours+export const SEGMENT_COLORS: Color[] = [...BODY_HAND_COLORS, ...FACE_COLORS];\ No newline at end of filediff --git a/freemocap-ui/src/components/viewport3d/viewport3d-types.ts b/freemocap-ui/src/components/viewport3d/viewport3d-types.tsnew file mode 100644index 00000000..7474ed3a--- /dev/null+++ b/freemocap-ui/src/components/viewport3d/viewport3d-types.ts@@ -0,0 +1,16 @@+import { Color } from "three";++export type { Point3d } from "@/services/server/ServerContextProvider";++export interface PointStyle {+ color: Color;+ scale: number;+}++/** Rigid body pose for a single bone segment, received from Python backend. */+export interface RigidBodyPose {+ bone_key: string;+ position: [number, number, number]; // (x, y, z) origin at parent joint+ orientation: [number, number, number, number]; // (w, x, y, z) quaternion+ length: number; // meters+}diff --git a/freemocap-ui/src/components/viewport3d/virtual-points.ts b/freemocap-ui/src/components/viewport3d/virtual-points.tsnew file mode 100644index 00000000..424cfb40--- /dev/null+++ b/freemocap-ui/src/components/viewport3d/virtual-points.ts@@ -0,0 +1,31 @@+import { Point3d } from "@/components/viewport3d/viewport3d-types";++/**+ * Resolve a point name to a 3D position. Handles both raw landmark names+ * (looked up directly in the points map) and virtual midpoint names+ * (head_center, neck_center, hips_center) computed from paired landmarks.+ */+export function resolvePoint(points: Map<string, Point3d>, name: string): Point3d | null {+ switch (name) {+ case "head_center": {+ const l = points.get("body.left_ear");+ const r = points.get("body.right_ear");+ if (!l || !r) return null;+ return { x: (l.x + r.x) / 2, y: (l.y + r.y) / 2, z: (l.z + r.z) / 2 };+ }+ case "neck_center": {+ const l = points.get("body.left_shoulder");+ const r = points.get("body.right_shoulder");+ if (!l || !r) return null;+ return { x: (l.x + r.x) / 2, y: (l.y + r.y) / 2, z: (l.z + r.z) / 2 };+ }+ case "hips_center": {+ const l = points.get("body.left_hip");+ const r = points.get("body.right_hip");+ if (!l || !r) return null;+ return { x: (l.x + r.x) / 2, y: (l.y + r.y) / 2, z: (l.z + r.z) / 2 };+ }+ default:+ return points.get(name) ?? null;+ }+}diff --git a/freemocap-ui/src/hooks/server-urls.ts b/freemocap-ui/src/hooks/server-urls.tsindex 0f414eaa..183aefbd 100644--- a/freemocap-ui/src/hooks/server-urls.ts+++ b/freemocap-ui/src/hooks/server-urls.ts@@ -1,20 +1,48 @@+const DEFAULT_HOST = 'localhost';+const DEFAULT_PORT = 53117;++type PortChangeCallback = (port: number) => void;+class ServerUrls {- private readonly host = 'localhost';- private readonly port = 53117;+ private readonly host = DEFAULT_HOST;+ private port = DEFAULT_PORT;+ private portChangeListeners = new Set<PortChangeCallback>();/**- * Get HTTP base URL+ * Update the port at runtime. Notifies all subscribers so components+ * can recreate connections with the correct URL.*/- getHttpUrl(): string {- return `http://${this.host}:${this.port}`;+ setPort(port: number): void {+ if (port === this.port) return;+ console.log(`[ServerUrls] Port updated: ${this.port} → ${port}`);+ this.port = port;+ for (const listener of this.portChangeListeners) {+ listener(port);+ }+ }++ getPort(): number {+ return this.port;}/**- * Get WebSocket base URL+ * Subscribe to port changes. Returns an unsubscribe function.*/+ onPortChange(callback: PortChangeCallback): () => void {+ this.portChangeListeners.add(callback);+ return () => {+ this.portChangeListeners.delete(callback);+ };+ }++ getHttpUrl(): string {+ return `http://${this.host}:${this.port}`;+ }+getWebSocketUrl(): string {return `ws://${this.host}:${this.port}/websocket/connect`;}+get endpoints() {const baseUrl = this.getHttpUrl();@@ -22,6 +50,7 @@ class ServerUrls {// Server managementhealth: `${baseUrl}/health`,shutdown: `${baseUrl}/shutdown`,+ settings: `${baseUrl}/settings`,// Camera endpointsdetectCameras: `${baseUrl}/skellycam/camera/detect`,@@ -59,5 +88,4 @@ class ServerUrls {}}-// Export singleton instance-export const serverUrls = new ServerUrls();+export const serverUrls = new ServerUrls();\ No newline at end of filediff --git a/freemocap-ui/src/hooks/useElectronApi.ts b/freemocap-ui/src/hooks/useElectronApi.tsindex d75a84bc..97456743 100644--- a/freemocap-ui/src/hooks/useElectronApi.ts+++ b/freemocap-ui/src/hooks/useElectronApi.ts@@ -1,16 +1,17 @@// src/hooks/useElectronAPI.tsimport {useEffect, useMemo, useState} from 'react';import {electronIpcClient, isElectron} from "@/services";+import {serverUrls} from "@/hooks/server-urls";interface UseElectronAPIReturn {isElectron: boolean;isLoading: boolean;api: typeof electronIpcClient | null;- // Helper methods for common operationspythonServer: {- start: (exePath?: string | null) => Promise<void>;+ start: (exePath?: string | null) => Promise<number>;stop: () => Promise<void>;isRunning: () => Promise<boolean>;+ getPort: () => Promise<number>;getStatus: () => Promise<{running: boolean;path: string | null;@@ -30,56 +31,45 @@ export function useElectronAPI(): UseElectronAPIReturn {const [isLoading, setIsLoading] = useState<boolean>(true);useEffect(() => {- // Check if we're in Electron environmentconst electronAvailable = isElectron();setIsElectronEnv(electronAvailable);setIsLoading(false);- // Log the environment for debuggingconsole.log('Electron environment detected:', electronAvailable);}, []);- // Create memoized helper objectsconst pythonServer = useMemo(() => {if (!isElectronEnv) return null;return {- start: async (exePath: string | null = null) => {- try {- await electronIpcClient.pythonServer.start.mutate({ exePath });- } catch (error) {- console.error('Failed to start Python server:', error);- throw error;- }+ /**+ * Start the Python server. Returns the port the server bound to.+ * Also updates the global serverUrls singleton so all HTTP/WS+ * connections automatically use the correct port.+ */+ start: async (exePath: string | null = null): Promise<number> => {+ const port: number = await electronIpcClient.pythonServer.start.mutate({ exePath });+ serverUrls.setPort(port);+ return port;},stop: async () => {- try {- await electronIpcClient.pythonServer.stop.mutate();- } catch (error) {- console.error('Failed to stop Python server:', error);- throw error;- }+ await electronIpcClient.pythonServer.stop.mutate();},isRunning: async () => {- try {- return await electronIpcClient.pythonServer.isRunning.query();- } catch (error) {- console.error('Failed to check Python server status:', error);- return false;- }+ return await electronIpcClient.pythonServer.isRunning.query();+ },+ getPort: async (): Promise<number> => {+ const port: number = await electronIpcClient.pythonServer.getPort.query();+ serverUrls.setPort(port);+ return port;},getStatus: async () => {- try {- const [running, path, processInfo] = await Promise.all([- electronIpcClient.pythonServer.isRunning.query(),- electronIpcClient.pythonServer.getExecutablePath.query(),- electronIpcClient.pythonServer.getProcessInfo.query(),- ]);- return { running, path, processInfo };- } catch (error) {- console.error('Failed to get Python server status:', error);- return { running: false, path: null, processInfo: null };- }+ const [running, path, processInfo] = await Promise.all([+ electronIpcClient.pythonServer.isRunning.query(),+ electronIpcClient.pythonServer.getExecutablePath.query(),+ electronIpcClient.pythonServer.getProcessInfo.query(),+ ]);+ return { running, path, processInfo };},};}, [isElectronEnv]);@@ -90,7 +80,7 @@ export function useElectronAPI(): UseElectronAPIReturn {return {openSelectDirectoryDialog: async () => {try {- return await electronIpcClient.fileSystem.openSelectDirectoryDialog.mutate();+ return await electronIpcClient.fileSystem.selectDirectory.mutate();} catch (error) {console.error('Failed to select directory:', error);return null;@@ -132,5 +122,4 @@ export function useElectronAPI(): UseElectronAPIReturn {};}-// Export a singleton instance for use outside of React components-export const electronAPI = isElectron() ? electronIpcClient : null;+export const electronAPI = isElectron() ? electronIpcClient : null;\ No newline at end of filediff --git a/freemocap-ui/src/hooks/useMocap.ts b/freemocap-ui/src/hooks/useMocap.tsindex 2d5c36f0..0233834a 100644--- a/freemocap-ui/src/hooks/useMocap.ts+++ b/freemocap-ui/src/hooks/useMocap.ts@@ -1,42 +1,70 @@-// hooks/useMocap.tsimport {useCallback} from 'react';import {useAppDispatch, useAppSelector} from '@/store/hooks';-import {useElectronIPC} from '@/services';import {- manualMocapRecordingPathChanged,- manualMocapRecordingPathCleared,- MocapConfig,- mocapConfigUpdated,+ MediapipeDetectorConfig,+ RealtimeFilterConfig,+ mocapDetectorConfigReplaced,+ mocapDetectorConfigUpdated,+ skeletonFilterConfigReplaced,+ skeletonFilterConfigUpdated,mocapDirectoryInfoUpdated,mocapErrorCleared,- processMocapRecording,- selectCanProcessMocapRecording,- selectCanStartMocapRecording,- selectIsUsingManualMocapPath,+ manualMocapRecordingPathChanged,+ manualMocapRecordingPathCleared,selectMocap,+ selectMocapDetectorConfig,+ selectSkeletonFilterConfig,selectMocapDirectoryInfo,selectMocapRecordingPath,+ selectCanProcessMocapRecording,+ selectCanStartMocapRecording,+ selectIsUsingManualMocapPath,startMocapRecording,stopMocapRecording,- updateMocapConfigOnServer+ processMocapRecording,+ updateMocapConfigOnServer,} from "@/store/slices/mocap";export function useMocap() {const dispatch = useAppDispatch();- const { api, isElectron } = useElectronIPC();+ const {api, isElectron} = useElectronIPC();const mocapState = useAppSelector(selectMocap);+ const detectorConfig = useAppSelector(selectMocapDetectorConfig);+ const skeletonFilterConfig = useAppSelector(selectSkeletonFilterConfig);const canStartRecording = useAppSelector(selectCanStartMocapRecording);const canProcessMocapRecording = useAppSelector(selectCanProcessMocapRecording);const mocapRecordingPath = useAppSelector(selectMocapRecordingPath);const directoryInfo = useAppSelector(selectMocapDirectoryInfo);const isUsingManualPath = useAppSelector(selectIsUsingManualMocapPath);- const updateMocapConfig = useCallback(- (updates: Partial<MocapConfig>) => {- // Update local state first- dispatch(mocapConfigUpdated(updates));- // Then sync to server - this reads from the updated state+ const updateDetectorConfig = useCallback(+ (updates: Partial<MediapipeDetectorConfig>) => {+ dispatch(mocapDetectorConfigUpdated(updates));+ dispatch(updateMocapConfigOnServer());+ },+ [dispatch]+ );++ const replaceDetectorConfig = useCallback(+ (config: MediapipeDetectorConfig) => {+ dispatch(mocapDetectorConfigReplaced(config));+ dispatch(updateMocapConfigOnServer());+ },+ [dispatch]+ );++ const updateSkeletonFilterConfig = useCallback(+ (updates: Partial<RealtimeFilterConfig>) => {+ dispatch(skeletonFilterConfigUpdated(updates));+ dispatch(updateMocapConfigOnServer());+ },+ [dispatch]+ );++ const replaceSkeletonFilterConfig = useCallback(+ (config: RealtimeFilterConfig) => {+ dispatch(skeletonFilterConfigReplaced(config));dispatch(updateMocapConfigOnServer());},[dispatch]@@ -50,11 +78,10 @@ export function useMocap() {}try {- const info = await api.fileSystem.validateMocapDirectory.query({ directoryPath });+ const info = await api.fileSystem.validateMocapDirectory.query({directoryPath});dispatch(mocapDirectoryInfoUpdated(info));} catch (error) {console.error('Failed to validate mocap directory:', error);- // Don't throw - just log the error}},[dispatch, isElectron, api]@@ -63,7 +90,6 @@ export function useMocap() {const setManualRecordingPath = useCallback(async (path: string) => {dispatch(manualMocapRecordingPathChanged(path));- // Validate the new pathawait validateDirectory(path);},[dispatch, validateDirectory]@@ -92,6 +118,8 @@ export function useMocap() {return {// Stateconfig: mocapState.config,+ detectorConfig,+ skeletonFilterConfig,error: mocapState.error,isLoading: mocapState.isLoading,isRecording: mocapState.isRecording,@@ -102,10 +130,12 @@ export function useMocap() {canStartRecording,canProcessMocapRecording,// Actions- updateMocapConfig,+ updateDetectorConfig,+ replaceDetectorConfig,+ updateSkeletonFilterConfig,+ replaceSkeletonFilterConfig,setManualRecordingPath,clearManualRecordingPath,- validateDirectory,dispatchStartMocapRecording,dispatchStopMocapRecording,dispatchProcessMocapRecording,diff --git a/freemocap-ui/src/layout/AppContent.tsx b/freemocap-ui/src/layout/AppContent.tsxindex 0ca1171d..535275c4 100644--- a/freemocap-ui/src/layout/AppContent.tsx+++ b/freemocap-ui/src/layout/AppContent.tsx@@ -1,29 +1,32 @@import * as React from 'react';-import {ThemeProvider} from '@mui/material/styles';-import {HashRouter} from 'react-router-dom';-import {CssBaseline} from "@mui/material";-import {BasePanelLayout} from "@/layout/BasePanelLayout";-import {createExtendedTheme} from "@/layout/paperbase-theme";-import {useAppSelector} from "@/store";-import {BaseContentRouter} from "@/layout/BaseContentRouter";+import { ThemeProvider } from '@mui/material/styles';+import { HashRouter } from 'react-router-dom';+import { CssBaseline } from '@mui/material';+import { BasePanelLayout } from '@/layout/BasePanelLayout';+import { createExtendedTheme } from '@/layout/paperbase-theme';+import { useAppSelector } from '@/store';+import { BaseContentRouter } from '@/layout/BaseContentRouter';+import { FirstLaunchRedirect } from '@/components/setup-wizard/FirstLaunchRedirect';+import { MenuNavigationListener } from '@/components/MenuNavigationListener';export const AppContent = function () {-const themeMode = useAppSelector(state => state.theme.mode);- // Create theme dynamically based on current modeconst theme = React.useMemo(() =>createExtendedTheme(themeMode),- [themeMode]+ [themeMode],);+return (<ThemeProvider theme={theme}>- <CssBaseline/>+ <CssBaseline /><HashRouter>+ <FirstLaunchRedirect />+ <MenuNavigationListener /><BasePanelLayout>- <BaseContentRouter/>+ <BaseContentRouter /></BasePanelLayout></HashRouter></ThemeProvider>);-}+};diff --git a/freemocap-ui/src/layout/BaseContentRouter.tsx b/freemocap-ui/src/layout/BaseContentRouter.tsxindex 3834b231..34818701 100644--- a/freemocap-ui/src/layout/BaseContentRouter.tsx+++ b/freemocap-ui/src/layout/BaseContentRouter.tsx@@ -1,20 +1,22 @@-// freemocap-ui/src/layout/BaseContent.tsximport React from 'react';-import {Navigate, Route, Routes} from 'react-router-dom';-import {CamerasPage} from "@/pages/CamerasPage";-import VideosPage from "@/pages/VideosPage";-import WelcomePage from "@/pages/WelcomePage";-import {Viewport3dPage} from "@/pages/Viewport3dPage";+import { Navigate, Route, Routes } from 'react-router-dom';+import { CamerasPage } from '@/pages/CamerasPage';+import VideosPage from '@/pages/VideosPage';+import WelcomePage from '@/pages/WelcomePage';+import { Viewport3dPage } from '@/pages/Viewport3dPage';+import { SettingsPage } from '@/pages/SettingsPage';export const BaseContentRouter: React.FC = () => {return (<Routes><Route path="/" element={<WelcomePage />} />- <Route path="/cameras" element={<CamerasPage/>}/>- <Route path="/videos" element={<VideosPage/>}/>- <Route path="/viewport3d" element={<Viewport3dPage/>}/>- <Route path="/videos" element={<VideosPage/>}/>- <Route path="*" element={<Navigate to="/" replace/>}/>+ <Route path="/cameras" element={<CamerasPage />} />+ <Route path="/videos" element={<VideosPage />} />+ <Route path="/viewport3d" element={<Viewport3dPage />} />+ <Route path="/settings" element={<SettingsPage />} />+ {/* Legacy route redirect */}+ <Route path="/setup" element={<Navigate to="/settings" replace />} />+ <Route path="*" element={<Navigate to="/" replace />} /></Routes>);};diff --git a/freemocap-ui/src/pages/CamerasPage.tsx b/freemocap-ui/src/pages/CamerasPage.tsxindex 31949e79..ab3a34a7 100644--- a/freemocap-ui/src/pages/CamerasPage.tsx+++ b/freemocap-ui/src/pages/CamerasPage.tsx@@ -10,16 +10,20 @@ import {} from "@/components/camera-views/camera-view-settings-overlay/CamerasViewSettingsOverlay";import {ThreeJsCanvas} from "@/components/viewport3d/ThreeJsCanvas";-interface CameraSettings {+export type LayoutDirection = 'vertical' | 'horizontal';++export interface CameraSettings {columns: number | null;show3dView: boolean;+ layoutDirection: LayoutDirection;}export const CamerasPage = () => {const theme = useTheme();const [settings, setSettings] = useState<CameraSettings>({- columns: null, // auto+ columns: null,show3dView: true,+ layoutDirection: 'horizontal',});const [resetKey, setResetKey] = useState<number>(0);@@ -31,6 +35,8 @@ export const CamerasPage = () => {setResetKey(prev => prev + 1);};+ const isHorizontal = settings.layoutDirection === 'horizontal';+return (<React.Fragment><Box sx={{@@ -52,47 +58,51 @@ export const CamerasPage = () => {onResetViews={handleResetViews}/>- <Box sx={{ flex: 1, overflow: 'hidden' }}>+ <Box sx={{flex: 1, overflow: 'hidden'}}>{settings.show3dView ? (- <PanelGroup key={`main-panels-${resetKey}`} direction="vertical">+ <PanelGroup+ key={`main-panels-${resetKey}-${settings.layoutDirection}`}+ direction={settings.layoutDirection}+ >{/* Camera Grid View Panel */}- <Panel defaultSize={80} minSize={20}>- <Box sx={{ height: '100%', overflow: 'auto' }}>+ <Panel defaultSize={isHorizontal ? 60 : 80} minSize={20}>+ <Box sx={{height: '100%', overflow: 'auto'}}><ErrorBoundary>- <CameraViewsGrid settings={settings} resetKey={resetKey} />+ <CameraViewsGrid settings={settings} resetKey={resetKey}/></ErrorBoundary></Box></Panel>- {/* Vertical Resize Handle */}+ {/* Resize Handle — adapts to layout direction */}<PanelResizeHandlestyle={{- height: "2px",- cursor: "row-resize",+ ...(isHorizontal+ ? {width: "4px", cursor: "col-resize"}+ : {height: "2px", cursor: "row-resize"}),backgroundColor: theme.palette.primary.dark,}}/>{/* 3D View Panel */}- <Panel defaultSize={20} minSize={10}>- <Box sx={{ height: '100%' }}>- <ThreeJsCanvas />+ <Panel defaultSize={isHorizontal ? 40 : 20} minSize={10}>+ <Box sx={{height: '100%'}}>+ <ThreeJsCanvas/></Box></Panel></PanelGroup>) : (- <Box sx={{ height: '100%', overflow: 'auto' }}>+ <Box sx={{height: '100%', overflow: 'auto'}}><ErrorBoundary>- <CameraViewsGrid settings={settings} resetKey={resetKey} />+ <CameraViewsGrid settings={settings} resetKey={resetKey}/></ErrorBoundary></Box>)}</Box>- <Box component="footer" sx={{ p: 1 }}>- <Footer />+ <Box component="footer" sx={{p: 1}}>+ <Footer/></Box></Box></React.Fragment>);-};+};\ No newline at end of filediff --git a/freemocap-ui/src/pages/SettingsPage.tsx b/freemocap-ui/src/pages/SettingsPage.tsxnew file mode 100644index 00000000..ffe2731b--- /dev/null+++ b/freemocap-ui/src/pages/SettingsPage.tsx@@ -0,0 +1,1510 @@+import React, { useState, useCallback, useEffect } from 'react';+import {+ Box,+ Typography,+ Switch,+ FormControlLabel,+ TextField,+ Slider,+ Select,+ MenuItem,+ FormControl,+ InputLabel,+ Paper,+ List,+ ListItemButton,+ ListItemIcon,+ ListItemText,+ Divider,+ Chip,+ Button,+ CircularProgress,+ Alert,+ Tooltip,+ LinearProgress,+ IconButton,+} from '@mui/material';+import { useTheme } from '@mui/material/styles';+import PaletteIcon from '@mui/icons-material/Palette';+import DnsIcon from '@mui/icons-material/Dns';+import FiberManualRecordIcon from '@mui/icons-material/FiberManualRecord';+import SquareFootIcon from '@mui/icons-material/SquareFoot';+import DirectionsRunIcon from '@mui/icons-material/DirectionsRun';+import CastConnectedIcon from '@mui/icons-material/CastConnected';+import ComputerIcon from '@mui/icons-material/Computer';+import MemoryIcon from '@mui/icons-material/Memory';+import SpeedIcon from '@mui/icons-material/Speed';+import StorageIcon from '@mui/icons-material/Storage';+import VideocamIcon from '@mui/icons-material/Videocam';+import CheckCircleIcon from '@mui/icons-material/CheckCircle';+import ErrorIcon from '@mui/icons-material/Error';+import WarningIcon from '@mui/icons-material/Warning';+import DownloadIcon from '@mui/icons-material/Download';+import RefreshIcon from '@mui/icons-material/Refresh';+import ArrowBackIcon from '@mui/icons-material/ArrowBack';+import CodeIcon from '@mui/icons-material/Code';+import { useNavigate } from 'react-router-dom';+import {+ useAppDispatch,+ useAppSelector,+ themeModeSet,+ themeModeToggled,+ recordingDirectoryChanged,+ useDelayStartToggled,+ delaySecondsChanged,+ useTimestampToggled,+ useIncrementToggled,+ baseNameChanged,+ recordingTagChanged,+ createSubfolderToggled,+ customSubfolderNameChanged,+ selectServerSettings,+} from '@/store';+import { ThemeMode } from '@/store/slices/theme/theme-types';+import { useCalibration } from '@/hooks/useCalibration';+import { useMocap } from '@/hooks/useMocap';+import { useServer } from '@/hooks/useServer';+import { useElectronIPC } from '@/services';+import {+ MediapipeModelComplexity,+ MEDIAPIPE_REALTIME_PRESET,+ MEDIAPIPE_POSTHOC_PRESET,+ DEFAULT_REALTIME_FILTER_CONFIG,+} from '@/store/slices/mocap';+import { SettingsEditor } from '@/components/settings-editor/SettingsEditor';++// ── Section IDs ──++type SectionId =+ | 'appearance'+ | 'connection'+ | 'recording'+ | 'calibration'+ | 'mocap'+ | 'vmc'+ | 'system'+ | 'editor';++interface SectionDef {+ id: SectionId;+ label: string;+ icon: React.ReactNode;+}++const SECTIONS: SectionDef[] = [+ { id: 'appearance', label: 'Appearance', icon: <PaletteIcon /> },+ { id: 'connection', label: 'Server Connection', icon: <DnsIcon /> },+ { id: 'recording', label: 'Recording', icon: <FiberManualRecordIcon /> },+ { id: 'calibration', label: 'Calibration', icon: <SquareFootIcon /> },+ { id: 'mocap', label: 'Motion Capture', icon: <DirectionsRunIcon /> },+ { id: 'vmc', label: 'VMC Output', icon: <CastConnectedIcon /> },+ { id: 'system', label: 'System Info', icon: <ComputerIcon /> },+ { id: 'editor', label: 'Raw Editor', icon: <CodeIcon /> },+];++// ── Setup wizard types (mirrors electron-side types) ──++interface CpuInfo { model: string; cores: number; threads: number; speedMhz: number }+interface RamInfo { totalGb: number; availableGb: number }+interface GpuInfo { name: string; vendor: string; vramMb: number | null; cudaAvailable: boolean; cudaVersion: string | null }+interface DiskInfo { path: string; totalGb: number; freeGb: number }+interface OsInfo { platform: string; release: string; arch: string; hostname: string }+type PerformanceTier = 'basic' | 'standard' | 'advanced' | 'pro';+interface PerformanceRecommendation {+ tier: PerformanceTier;+ label: string;+ description: string;+ maxCameras: number;+ maxResolution: string;+ realtimeTracking: boolean;+ warnings: string[];+}+interface SystemScanResult {+ cpu: CpuInfo;+ ram: RamInfo;+ gpus: GpuInfo[];+ disk: DiskInfo;+ os: OsInfo;+ recommendation: PerformanceRecommendation;+ scannedAt: string;+}++type DependencyStatus = 'installed' | 'missing' | 'outdated' | 'checking' | 'installing' | 'error';+interface DependencyInfo {+ id: string;+ name: string;+ description: string;+ required: boolean;+ status: DependencyStatus;+ version: string | null;+ installedPath: string | null;+ error: string | null;+}++const SYSTEM_SCAN_KEY = 'lastSystemScan';++const TIER_COLORS: Record<PerformanceTier, string> = {+ basic: '#ff9800',+ standard: '#2196f3',+ advanced: '#4caf50',+ pro: '#00e5ff',+};++const TIER_EMOJIS: Record<PerformanceTier, string> = {+ basic: '🐢',+ standard: '🏃',+ advanced: '🚀',+ pro: '⚡',+};++// ── Shared layout components ──++function SectionHeader({ title, description }: { title: string; description?: string }) {+ const theme = useTheme();+ return (+ <Box sx={{ mb: 3 }}>+ <Typography variant="h5" sx={{ fontWeight: 700, mb: 0.5 }}>+ {title}+ </Typography>+ {description && (+ <Typography variant="body2" sx={{ color: theme.palette.text.secondary }}>+ {description}+ </Typography>+ )}+ </Box>+ );+}++function SettingRow({ label, description, children }: { label: string; description?: string; children: React.ReactNode }) {+ const theme = useTheme();+ return (+ <Box+ sx={{+ display: 'flex',+ alignItems: 'flex-start',+ justifyContent: 'space-between',+ py: 1.5,+ gap: 3,+ }}+ >+ <Box sx={{ flex: 1, minWidth: 0 }}>+ <Typography variant="body1" sx={{ fontWeight: 500 }}>+ {label}+ </Typography>+ {description && (+ <Typography variant="body2" sx={{ color: theme.palette.text.secondary, mt: 0.25 }}>+ {description}+ </Typography>+ )}+ </Box>+ <Box sx={{ flexShrink: 0, display: 'flex', alignItems: 'center' }}>+ {children}+ </Box>+ </Box>+ );+}++function SettingGroup({ title, children }: { title: string; children: React.ReactNode }) {+ const theme = useTheme();+ return (+ <Paper+ elevation={0}+ sx={{+ border: `1px solid ${theme.palette.divider}`,+ borderRadius: 2,+ p: 2.5,+ mb: 2,+ }}+ >+ <Typography+ variant="overline"+ sx={{+ fontWeight: 700,+ color: theme.palette.text.secondary,+ letterSpacing: 1.2,+ mb: 1,+ display: 'block',+ }}+ >+ {title}+ </Typography>+ <Divider sx={{ mb: 1 }} />+ {children}+ </Paper>+ );+}++// ── Section: Appearance ──++function AppearanceSection() {+ const dispatch = useAppDispatch();+ const themeMode = useAppSelector(state => state.theme.mode);++ return (+ <>+ <SectionHeader+ title="Appearance"+ description="Customize how FreeMoCap looks."+ />+ <SettingGroup title="Theme">+ <SettingRow+ label="Dark Mode"+ description="Toggle between light and dark color schemes."+ >+ <Switch+ checked={themeMode === 'dark'}+ onChange={() => dispatch(themeModeToggled())}+ />+ </SettingRow>+ <SettingRow+ label="Color Scheme"+ description="Choose your preferred theme."+ >+ <FormControl size="small" sx={{ minWidth: 140 }}>+ <Select+ value={themeMode}+ onChange={(e) => dispatch(themeModeSet(e.target.value as ThemeMode))}+ >+ <MenuItem value="dark">Dark</MenuItem>+ <MenuItem value="light">Light</MenuItem>+ </Select>+ </FormControl>+ </SettingRow>+ </SettingGroup>+ </>+ );+}++// ── Section: Server Connection ──++function ConnectionSection() {+ const { isConnected, connectionState, connect, disconnect } = useServer();+ const theme = useTheme();++ return (+ <>+ <SectionHeader+ title="Server Connection"+ description="Connection to the FreeMoCap backend server."+ />+ <SettingGroup title="Status">+ <SettingRow+ label="Connection Status"+ description={`Current state: ${connectionState}`}+ >+ <Chip+ label={isConnected ? 'Connected' : 'Disconnected'}+ color={isConnected ? 'success' : 'error'}+ size="small"+ variant="outlined"+ />+ </SettingRow>+ <SettingRow+ label="Server Address"+ description="Backend server URL (configured at build time)."+ >+ <Typography variant="body2" sx={{ fontFamily: 'monospace', color: theme.palette.text.secondary }}>+ localhost:53117+ </Typography>+ </SettingRow>+ <SettingRow label="Actions">+ <Box sx={{ display: 'flex', gap: 1 }}>+ <Button+ size="small"+ variant="outlined"+ onClick={connect}+ disabled={isConnected}+ >+ Connect+ </Button>+ <Button+ size="small"+ variant="outlined"+ color="error"+ onClick={disconnect}+ disabled={!isConnected}+ >+ Disconnect+ </Button>+ </Box>+ </SettingRow>+ </SettingGroup>+ </>+ );+}++// ── Section: Recording ──++function RecordingSection() {+ const dispatch = useAppDispatch();+ const recording = useAppSelector(state => state.recording);+ const { isElectron, api } = useElectronIPC();++ const handleBrowseDirectory = useCallback(async () => {+ if (!isElectron || !api) return;+ const result = await api.fileSystem.selectDirectory.query();+ if (result) {+ dispatch(recordingDirectoryChanged(result as string));+ }+ }, [dispatch, isElectron, api]);++ return (+ <>+ <SectionHeader+ title="Recording"+ description="Configure how recordings are saved and named."+ />+ <SettingGroup title="Storage">+ <SettingRow+ label="Recording Directory"+ description="Base folder for saving recordings."+ >+ <Box sx={{ display: 'flex', gap: 1, alignItems: 'center' }}>+ <TextField+ size="small"+ value={recording.recordingDirectory}+ onChange={(e) => dispatch(recordingDirectoryChanged(e.target.value))}+ sx={{ minWidth: 260 }}+ inputProps={{ style: { fontFamily: 'monospace', fontSize: 13 } }}+ />+ {isElectron && (+ <Button size="small" variant="outlined" onClick={handleBrowseDirectory}>+ Browse+ </Button>+ )}+ </Box>+ </SettingRow>+ <SettingRow+ label="Create Subfolder"+ description="Put each recording session in its own subfolder."+ >+ <Switch+ checked={recording.config.createSubfolder}+ onChange={(_, v) => dispatch(createSubfolderToggled(v))}+ />+ </SettingRow>+ {recording.config.createSubfolder && (+ <SettingRow+ label="Custom Subfolder Name"+ description="Leave blank for auto-generated timestamp name."+ >+ <TextField+ size="small"+ value={recording.config.customSubfolderName}+ onChange={(e) => dispatch(customSubfolderNameChanged(e.target.value))}+ placeholder="(auto)"+ sx={{ minWidth: 200 }}+ />+ </SettingRow>+ )}+ </SettingGroup>++ <SettingGroup title="Naming">+ <SettingRow+ label="Use Timestamp"+ description="Include timestamp in recording name."+ >+ <Switch+ checked={recording.config.useTimestamp}+ onChange={(_, v) => dispatch(useTimestampToggled(v))}+ />+ </SettingRow>+ <SettingRow+ label="Use Increment"+ description="Append an auto-incrementing number."+ >+ <Switch+ checked={recording.config.useIncrement}+ onChange={(_, v) => dispatch(useIncrementToggled(v))}+ />+ </SettingRow>+ {!recording.config.useTimestamp && (+ <SettingRow+ label="Base Name"+ description="Base name for recordings when not using timestamp."+ >+ <TextField+ size="small"+ value={recording.config.baseName}+ onChange={(e) => dispatch(baseNameChanged(e.target.value))}+ sx={{ minWidth: 200 }}+ />+ </SettingRow>+ )}+ <SettingRow+ label="Recording Tag"+ description="Optional tag appended to the recording name."+ >+ <TextField+ size="small"+ value={recording.config.recordingTag}+ onChange={(e) => dispatch(recordingTagChanged(e.target.value))}+ placeholder="(none)"+ sx={{ minWidth: 200 }}+ />+ </SettingRow>+ </SettingGroup>++ <SettingGroup title="Delay Start">+ <SettingRow+ label="Delay Before Recording"+ description="Add a countdown before recording starts."+ >+ <Switch+ checked={recording.config.useDelayStart}+ onChange={(_, v) => dispatch(useDelayStartToggled(v))}+ />+ </SettingRow>+ {recording.config.useDelayStart && (+ <SettingRow+ label="Delay Duration"+ description="Seconds to wait before recording begins."+ >+ <TextField+ size="small"+ type="number"+ value={recording.config.delaySeconds}+ onChange={(e) => dispatch(delaySecondsChanged(Number(e.target.value)))}+ inputProps={{ min: 1, max: 30 }}+ sx={{ width: 100 }}+ />+ </SettingRow>+ )}+ </SettingGroup>++ <SettingGroup title="Preview">+ <Box sx={{ fontFamily: 'monospace', fontSize: 13, opacity: 0.7, p: 1 }}>+ <Typography variant="caption" sx={{ display: 'block' }}>+ Recording name: <strong>{recording.computed.recordingName || '(empty)'}</strong>+ </Typography>+ <Typography variant="caption" sx={{ display: 'block' }}>+ Full path: <strong>{recording.computed.fullRecordingPath}</strong>+ </Typography>+ </Box>+ </SettingGroup>+ </>+ );+}++// ── Section: Calibration ──++function CalibrationSection() {+ const { config, updateCalibrationConfig, isLoading } = useCalibration();++ return (+ <>+ <SectionHeader+ title="Calibration"+ description="Camera calibration settings for multi-camera setups."+ />+ <SettingGroup title="ChArUco Board">+ <SettingRow+ label="X Squares"+ description="Number of squares along the X axis."+ >+ <TextField+ size="small"+ type="number"+ value={config.charucoBoardXSquares}+ onChange={(e) => updateCalibrationConfig({ charucoBoardXSquares: Number(e.target.value) })}+ inputProps={{ min: 2, max: 20 }}+ disabled={isLoading}+ sx={{ width: 100 }}+ />+ </SettingRow>+ <SettingRow+ label="Y Squares"+ description="Number of squares along the Y axis."+ >+ <TextField+ size="small"+ type="number"+ value={config.charucoBoardYSquares}+ onChange={(e) => updateCalibrationConfig({ charucoBoardYSquares: Number(e.target.value) })}+ inputProps={{ min: 2, max: 20 }}+ disabled={isLoading}+ sx={{ width: 100 }}+ />+ </SettingRow>+ <SettingRow+ label="Square Length (mm)"+ description="Physical size of each square on the board."+ >+ <TextField+ size="small"+ type="number"+ value={config.charucoSquareLength}+ onChange={(e) => updateCalibrationConfig({ charucoSquareLength: Number(e.target.value) })}+ inputProps={{ min: 1, step: 0.5 }}+ disabled={isLoading}+ sx={{ width: 100 }}+ />+ </SettingRow>+ </SettingGroup>++ <SettingGroup title="Solver">+ <SettingRow+ label="Solver Method"+ description="Algorithm used to solve camera calibration."+ >+ <FormControl size="small" sx={{ minWidth: 140 }}>+ <Select+ value={config.solverMethod}+ onChange={(e) => updateCalibrationConfig({ solverMethod: e.target.value as 'anipose' | 'pyceres' })}+ disabled={isLoading}+ >+ <MenuItem value="anipose">Anipose</MenuItem>+ <MenuItem value="pyceres">PyCeres</MenuItem>+ </Select>+ </FormControl>+ </SettingRow>+ <SettingRow+ label="Use Ground Plane"+ description="Apply ground plane constraint to calibration."+ >+ <Switch+ checked={config.useGroundplane}+ onChange={(_, v) => updateCalibrationConfig({ useGroundplane: v })}+ disabled={isLoading}+ />+ </SettingRow>+ </SettingGroup>++ <SettingGroup title="Recording">+ <SettingRow+ label="Live Track ChArUco"+ description="Show ChArUco detection overlay while recording."+ >+ <Switch+ checked={config.liveTrackCharuco}+ onChange={(_, v) => updateCalibrationConfig({ liveTrackCharuco: v })}+ disabled={isLoading}+ />+ </SettingRow>+ <SettingRow+ label="Min Shared Views Per Camera"+ description="Minimum board observations shared between camera pairs."+ >+ <TextField+ size="small"+ type="number"+ value={config.minSharedViewsPerCamera}+ onChange={(e) => updateCalibrationConfig({ minSharedViewsPerCamera: Number(e.target.value) })}+ inputProps={{ min: 1, max: 200 }}+ disabled={isLoading}+ sx={{ width: 100 }}+ />+ </SettingRow>+ <SettingRow+ label="Auto-Stop on Min View Count"+ description="Automatically stop recording when minimum views are reached."+ >+ <Switch+ checked={config.autoStopOnMinViewCount}+ onChange={(_, v) => updateCalibrationConfig({ autoStopOnMinViewCount: v })}+ disabled={isLoading}+ />+ </SettingRow>+ </SettingGroup>+ </>+ );+}++// ── Section: Motion Capture ──++const MODEL_COMPLEXITY_LABELS: Record<MediapipeModelComplexity, string> = {+ 0: 'Lite (fastest)',+ 1: 'Full (balanced)',+ 2: 'Heavy (most accurate)',+};++function MocapSection() {+ const {+ detectorConfig,+ skeletonFilterConfig,+ updateDetectorConfig,+ replaceDetectorConfig,+ updateSkeletonFilterConfig,+ replaceSkeletonFilterConfig,+ isLoading,+ } = useMocap();++ const detectPreset = useCallback(() => {+ if (+ detectorConfig.model_complexity === 0 &&+ !detectorConfig.enable_segmentation &&+ !detectorConfig.smooth_segmentation+ ) return 'realtime';+ if (+ detectorConfig.model_complexity === 2 &&+ detectorConfig.enable_segmentation &&+ detectorConfig.smooth_segmentation+ ) return 'posthoc';+ return 'custom';+ }, [detectorConfig]);++ const currentPreset = detectPreset();++ return (+ <>+ <SectionHeader+ title="Motion Capture"+ description="MediaPipe detector and skeleton filter configuration."+ />++ {/* Detector */}+ <SettingGroup title="MediaPipe Detector">+ <SettingRow+ label="Preset"+ description="Quick-select a tuned detector configuration."+ >+ <Box sx={{ display: 'flex', gap: 1 }}>+ <Chip+ label="Realtime"+ size="small"+ variant={currentPreset === 'realtime' ? 'filled' : 'outlined'}+ color={currentPreset === 'realtime' ? 'primary' : 'default'}+ onClick={() => replaceDetectorConfig({ ...MEDIAPIPE_REALTIME_PRESET })}+ disabled={isLoading}+ sx={{ cursor: 'pointer' }}+ />+ <Chip+ label="Posthoc"+ size="small"+ variant={currentPreset === 'posthoc' ? 'filled' : 'outlined'}+ color={currentPreset === 'posthoc' ? 'primary' : 'default'}+ onClick={() => replaceDetectorConfig({ ...MEDIAPIPE_POSTHOC_PRESET })}+ disabled={isLoading}+ sx={{ cursor: 'pointer' }}+ />+ {currentPreset === 'custom' && (+ <Chip label="Custom" size="small" variant="outlined" color="warning" />+ )}+ </Box>+ </SettingRow>+ <SettingRow+ label="Model Complexity"+ description="Controls accuracy vs. speed tradeoff."+ >+ <FormControl size="small" sx={{ minWidth: 180 }}>+ <Select+ value={detectorConfig.model_complexity}+ onChange={(e) => updateDetectorConfig({ model_complexity: e.target.value as MediapipeModelComplexity })}+ disabled={isLoading}+ >+ <MenuItem value={0}>{MODEL_COMPLEXITY_LABELS[0]}</MenuItem>+ <MenuItem value={1}>{MODEL_COMPLEXITY_LABELS[1]}</MenuItem>+ <MenuItem value={2}>{MODEL_COMPLEXITY_LABELS[2]}</MenuItem>+ </Select>+ </FormControl>+ </SettingRow>+ <SettingRow+ label={`Min Detection Confidence: ${detectorConfig.min_detection_confidence.toFixed(2)}`}+ description="Minimum score for initial pose detection."+ >+ <Slider+ value={detectorConfig.min_detection_confidence}+ onChange={(_, v) => updateDetectorConfig({ min_detection_confidence: v as number })}+ min={0} max={1} step={0.05} size="small"+ disabled={isLoading}+ sx={{ width: 180 }}+ />+ </SettingRow>+ <SettingRow+ label={`Min Tracking Confidence: ${detectorConfig.min_tracking_confidence.toFixed(2)}`}+ description="Minimum score for frame-to-frame tracking."+ >+ <Slider+ value={detectorConfig.min_tracking_confidence}+ onChange={(_, v) => updateDetectorConfig({ min_tracking_confidence: v as number })}+ min={0} max={1} step={0.05} size="small"+ disabled={isLoading}+ sx={{ width: 180 }}+ />+ </SettingRow>+ <SettingRow label="Smooth Landmarks">+ <Switch+ size="small"+ checked={detectorConfig.smooth_landmarks}+ onChange={(_, v) => updateDetectorConfig({ smooth_landmarks: v })}+ disabled={isLoading}+ />+ </SettingRow>+ <SettingRow label="Enable Segmentation">+ <Switch+ size="small"+ checked={detectorConfig.enable_segmentation}+ onChange={(_, v) => updateDetectorConfig({ enable_segmentation: v })}+ disabled={isLoading}+ />+ </SettingRow>+ <SettingRow label="Smooth Segmentation">+ <Switch+ size="small"+ checked={detectorConfig.smooth_segmentation}+ onChange={(_, v) => updateDetectorConfig({ smooth_segmentation: v })}+ disabled={isLoading || !detectorConfig.enable_segmentation}+ />+ </SettingRow>+ <SettingRow label="Refine Face Landmarks">+ <Switch+ size="small"+ checked={detectorConfig.refine_face_landmarks}+ onChange={(_, v) => updateDetectorConfig({ refine_face_landmarks: v })}+ disabled={isLoading}+ />+ </SettingRow>+ <SettingRow label="Static Image Mode">+ <Switch+ size="small"+ checked={detectorConfig.static_image_mode}+ onChange={(_, v) => updateDetectorConfig({ static_image_mode: v })}+ disabled={isLoading}+ />+ </SettingRow>+ </SettingGroup>++ {/* Skeleton Filter */}+ <SettingGroup title="Skeleton Filter">+ <Box sx={{ display: 'flex', justifyContent: 'flex-end', mb: 1 }}>+ <Button+ size="small"+ variant="text"+ onClick={() => replaceSkeletonFilterConfig({ ...DEFAULT_REALTIME_FILTER_CONFIG })}+ disabled={isLoading}+ >+ Reset Defaults+ </Button>+ </Box>++ <SettingRow+ label="Height (meters)"+ description="Subject height for bone length estimation."+ >+ <TextField+ size="small"+ type="number"+ value={skeletonFilterConfig.height_meters}+ onChange={(e) => updateSkeletonFilterConfig({ height_meters: Number(e.target.value) })}+ inputProps={{ min: 0.5, max: 2.5, step: 0.01 }}+ disabled={isLoading}+ sx={{ width: 100 }}+ />+ </SettingRow>++ <Typography variant="caption" sx={{ display: 'block', mt: 1, mb: 0.5, fontWeight: 600, opacity: 0.6 }}>+ ONE EURO FILTER+ </Typography>+ <SettingRow label={`Min Cutoff: ${skeletonFilterConfig.min_cutoff.toFixed(2)}`}>+ <Slider+ value={skeletonFilterConfig.min_cutoff}+ onChange={(_, v) => updateSkeletonFilterConfig({ min_cutoff: v as number })}+ min={0.01} max={10} step={0.01} size="small"+ disabled={isLoading} sx={{ width: 180 }}+ />+ </SettingRow>+ <SettingRow label={`Beta: ${skeletonFilterConfig.beta.toFixed(3)}`}>+ <Slider+ value={skeletonFilterConfig.beta}+ onChange={(_, v) => updateSkeletonFilterConfig({ beta: v as number })}+ min={0} max={1} step={0.001} size="small"+ disabled={isLoading} sx={{ width: 180 }}+ />+ </SettingRow>+ <SettingRow label={`D Cutoff: ${skeletonFilterConfig.d_cutoff.toFixed(2)}`}>+ <Slider+ value={skeletonFilterConfig.d_cutoff}+ onChange={(_, v) => updateSkeletonFilterConfig({ d_cutoff: v as number })}+ min={0.01} max={10} step={0.01} size="small"+ disabled={isLoading} sx={{ width: 180 }}+ />+ </SettingRow>++ <Typography variant="caption" sx={{ display: 'block', mt: 1, mb: 0.5, fontWeight: 600, opacity: 0.6 }}>+ FABRIK IK+ </Typography>+ <SettingRow label={`Tolerance: ${skeletonFilterConfig.fabrik_tolerance.toFixed(4)}`}>+ <Slider+ value={skeletonFilterConfig.fabrik_tolerance}+ onChange={(_, v) => updateSkeletonFilterConfig({ fabrik_tolerance: v as number })}+ min={0.0001} max={0.1} step={0.0001} size="small"+ disabled={isLoading} sx={{ width: 180 }}+ />+ </SettingRow>+ <SettingRow label="Max Iterations">+ <TextField+ size="small"+ type="number"+ value={skeletonFilterConfig.fabrik_max_iterations}+ onChange={(e) => updateSkeletonFilterConfig({ fabrik_max_iterations: Number(e.target.value) })}+ inputProps={{ min: 1, max: 100 }}+ disabled={isLoading}+ sx={{ width: 100 }}+ />+ </SettingRow>++ <Typography variant="caption" sx={{ display: 'block', mt: 1, mb: 0.5, fontWeight: 600, opacity: 0.6 }}>+ POINT GATING+ </Typography>+ <SettingRow label="Max Reprojection Error (px)">+ <TextField+ size="small"+ type="number"+ value={skeletonFilterConfig.max_reprojection_error_px}+ onChange={(e) => updateSkeletonFilterConfig({ max_reprojection_error_px: Number(e.target.value) })}+ inputProps={{ min: 0, step: 1 }}+ disabled={isLoading}+ sx={{ width: 100 }}+ />+ </SettingRow>+ <SettingRow label="Max Velocity (m/s)">+ <TextField+ size="small"+ type="number"+ value={skeletonFilterConfig.max_velocity_m_per_s}+ onChange={(e) => updateSkeletonFilterConfig({ max_velocity_m_per_s: Number(e.target.value) })}+ inputProps={{ min: 0, step: 0.5 }}+ disabled={isLoading}+ sx={{ width: 100 }}+ />+ </SettingRow>+ <SettingRow label="Max Rejected Streak">+ <TextField+ size="small"+ type="number"+ value={skeletonFilterConfig.max_rejected_streak}+ onChange={(e) => updateSkeletonFilterConfig({ max_rejected_streak: Number(e.target.value) })}+ inputProps={{ min: 0 }}+ disabled={isLoading}+ sx={{ width: 100 }}+ />+ </SettingRow>+ </SettingGroup>+ </>+ );+}++// ── Section: VMC Output ──++function VMCSection() {+ const { send, isConnected } = useServer();+ const settings = useAppSelector(selectServerSettings);++ const vmcEnabled = settings?.vmc?.enabled ?? false;+ const vmcHost = settings?.vmc?.host ?? '127.0.0.1';+ const vmcPort = settings?.vmc?.port ?? 39539;++ const patchVMC = useCallback(+ (patch: Record<string, unknown>) => {+ send({ message_type: 'settings/patch', patch: { vmc: patch } });+ },+ [send],+ );++ return (+ <>+ <SectionHeader+ title="VMC Output"+ description="Virtual Motion Capture protocol streaming settings."+ />+ <SettingGroup title="VMC Streaming">+ <SettingRow+ label="Enable VMC Output"+ description="Stream skeleton data via VMC protocol over UDP."+ >+ <Switch+ checked={vmcEnabled}+ onChange={() => patchVMC({ enabled: !vmcEnabled })}+ disabled={!isConnected}+ />+ </SettingRow>+ <SettingRow+ label="Host"+ description="Target IP address for VMC packets."+ >+ <TextField+ size="small"+ value={vmcHost}+ onChange={(e) => {+ const val = e.target.value.trim();+ if (val.length > 0) patchVMC({ host: val });+ }}+ disabled={!isConnected || !vmcEnabled}+ sx={{ width: 160 }}+ inputProps={{ style: { fontFamily: 'monospace', fontSize: 13 } }}+ />+ </SettingRow>+ <SettingRow+ label="Port"+ description="UDP port for VMC packets (default 39539)."+ >+ <TextField+ size="small"+ type="number"+ value={vmcPort}+ onChange={(e) => {+ const val = parseInt(e.target.value, 10);+ if (!isNaN(val) && val > 0 && val <= 65535) patchVMC({ port: val });+ }}+ disabled={!isConnected || !vmcEnabled}+ inputProps={{ min: 1, max: 65535 }}+ sx={{ width: 120 }}+ />+ </SettingRow>+ {!isConnected && (+ <Alert severity="info" sx={{ mt: 1 }}>+ Connect to the backend server to configure VMC settings.+ </Alert>+ )}+ </SettingGroup>+ </>+ );+}++// ── Section: System Info ──++function DependencyStatusIcon({ status }: { status: DependencyStatus }) {+ switch (status) {+ case 'installed':+ return <CheckCircleIcon sx={{ color: '#4caf50', fontSize: 20 }} />;+ case 'missing':+ return <ErrorIcon sx={{ color: '#f44336', fontSize: 20 }} />;+ case 'outdated':+ return <WarningIcon sx={{ color: '#ff9800', fontSize: 20 }} />;+ case 'checking':+ case 'installing':+ return <CircularProgress size={18} />;+ case 'error':+ return <ErrorIcon sx={{ color: '#f44336', fontSize: 20 }} />;+ }+}++function SystemSection() {+ const theme = useTheme();+ const { isElectron, api } = useElectronIPC();++ const [scanning, setScanning] = useState(false);+ const [scanResult, setScanResult] = useState<SystemScanResult | null>(null);+ const [dependencies, setDependencies] = useState<DependencyInfo[]>([]);+ const [installing, setInstalling] = useState<string | null>(null);++ const runScan = useCallback(async () => {+ if (!isElectron || !api) return;+ setScanning(true);+ try {+ const result = await api.system.scan.query();+ const typed = result as SystemScanResult;+ setScanResult(typed);+ await api.settings.set.mutate({ key: SYSTEM_SCAN_KEY, value: typed });+ } catch (err) {+ console.error('System scan failed:', err);+ } finally {+ setScanning(false);+ }+ }, [isElectron, api]);++ const detectDeps = useCallback(async () => {+ if (!isElectron || !api) return;+ try {+ const result = await api.dependencies.detectAll.query();+ setDependencies(result as DependencyInfo[]);+ } catch (err) {+ console.error('Dependency detection failed:', err);+ }+ }, [isElectron, api]);++ const installDep = useCallback(async (depId: string) => {+ if (!isElectron || !api) return;+ setInstalling(depId);+ try {+ const updated = await api.dependencies.install.mutate({ dependencyId: depId });+ setDependencies(prev =>+ prev.map(d => d.id === depId ? (updated as DependencyInfo) : d),+ );+ if (depId === 'uv') {+ const envInfo = await api.dependencies.detect.query({ dependencyId: 'python-env' });+ setDependencies(prev =>+ prev.map(d => d.id === 'python-env' ? (envInfo as DependencyInfo) : d),+ );+ }+ } catch (err) {+ console.error(`Failed to install ${depId}:`, err);+ setDependencies(prev =>+ prev.map(d =>+ d.id === depId+ ? { ...d, status: 'error' as DependencyStatus, error: err instanceof Error ? err.message : String(err) }+ : d,+ ),+ );+ } finally {+ setInstalling(null);+ }+ }, [isElectron, api]);++ // Load persisted scan on mount+ useEffect(() => {+ if (!isElectron || !api) return;+ api.settings.get.query({ key: SYSTEM_SCAN_KEY }).then(result => {+ if (result && typeof result === 'object' && 'cpu' in (result as object)) {+ setScanResult(result as SystemScanResult);+ }+ }).catch(() => { /* no persisted scan */ });+ }, [isElectron, api]);++ if (!isElectron) {+ return (+ <>+ <SectionHeader+ title="System Info"+ description="System scanning is only available in the desktop app."+ />+ <Alert severity="info">+ Connect to a running FreeMoCap server via the desktop app to view system information and manage dependencies.+ </Alert>+ </>+ );+ }++ const rec = scanResult?.recommendation;+ const tierColor = rec ? TIER_COLORS[rec.tier] : undefined;++ return (+ <>+ <SectionHeader+ title="System Info"+ description="Hardware information, performance tier, and dependency status."+ />++ {/* Performance Tier */}+ <SettingGroup title="Performance Tier">+ {scanning ? (+ <Box sx={{ textAlign: 'center', py: 4 }}>+ <CircularProgress size={40} />+ <Typography sx={{ mt: 1.5, color: theme.palette.text.secondary }}>+ Scanning your system...+ </Typography>+ </Box>+ ) : scanResult && rec ? (+ <>+ <Paper+ elevation={0}+ sx={{+ p: 2, mb: 2,+ border: `2px solid ${tierColor}`,+ borderRadius: 2,+ background: `${tierColor}11`,+ textAlign: 'center',+ }}+ >+ <Typography variant="h5" sx={{ fontWeight: 700, color: tierColor }}>+ {TIER_EMOJIS[rec.tier]} {rec.label} System+ </Typography>+ <Typography variant="body2" sx={{ mt: 0.5, color: theme.palette.text.secondary }}>+ {rec.description}+ </Typography>+ <Box sx={{ display: 'flex', justifyContent: 'center', gap: 1.5, mt: 1.5, flexWrap: 'wrap' }}>+ <Chip+ icon={<VideocamIcon />}+ label={`Up to ${rec.maxCameras} cameras`}+ size="small"+ sx={{ borderColor: tierColor, color: tierColor }}+ variant="outlined"+ />+ <Chip+ label={`${rec.maxResolution} max`}+ size="small"+ sx={{ borderColor: tierColor, color: tierColor }}+ variant="outlined"+ />+ {rec.realtimeTracking && (+ <Chip+ icon={<SpeedIcon />}+ label="Real-time tracking"+ size="small"+ sx={{ borderColor: tierColor, color: tierColor }}+ variant="outlined"+ />+ )}+ </Box>+ </Paper>++ {/* Hardware grid */}+ <Box sx={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 1.5, mb: 2 }}>+ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>+ <MemoryIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>CPU</Typography>+ </Box>+ <Typography variant="body2" sx={{ fontWeight: 500, fontSize: '0.8rem' }}>+ {scanResult.cpu.model}+ </Typography>+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>+ {scanResult.cpu.threads} threads · {scanResult.cpu.cores} cores · {scanResult.cpu.speedMhz} MHz+ </Typography>+ </Paper>++ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>+ <ComputerIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>MEMORY</Typography>+ </Box>+ <Typography variant="body2" sx={{ fontWeight: 500 }}>+ {scanResult.ram.totalGb} GB total+ </Typography>+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>+ {scanResult.ram.availableGb} GB available+ </Typography>+ </Paper>++ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>+ <SpeedIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>GPU</Typography>+ </Box>+ {scanResult.gpus.length > 0 ? scanResult.gpus.map((gpu, i) => (+ <Box key={i}>+ <Typography variant="body2" sx={{ fontWeight: 500, fontSize: '0.8rem' }}>+ {gpu.name}+ </Typography>+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>+ {gpu.vramMb ? `${Math.round(gpu.vramMb / 1024)} GB VRAM` : 'VRAM unknown'}+ {gpu.cudaAvailable ? ` · CUDA ${gpu.cudaVersion || '✓'}` : ''}+ </Typography>+ </Box>+ )) : (+ <Typography variant="body2" sx={{ color: theme.palette.text.disabled }}>+ No dedicated GPU detected+ </Typography>+ )}+ </Paper>++ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>+ <StorageIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>DISK</Typography>+ </Box>+ <Typography variant="body2" sx={{ fontWeight: 500 }}>+ {scanResult.disk.freeGb} GB free+ </Typography>+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>+ of {scanResult.disk.totalGb} GB total+ </Typography>+ {scanResult.disk.freeGb > 0 && scanResult.disk.freeGb < 20 && (+ <LinearProgress+ variant="determinate"+ value={((scanResult.disk.totalGb - scanResult.disk.freeGb) / scanResult.disk.totalGb) * 100}+ color="warning"+ sx={{ mt: 0.5, height: 4, borderRadius: 1 }}+ />+ )}+ </Paper>+ </Box>++ {rec.warnings.length > 0 && (+ <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.5, mb: 2 }}>+ {rec.warnings.map((w, i) => (+ <Alert key={i} severity="warning" sx={{ py: 0, fontSize: '0.75rem' }}>+ {w}+ </Alert>+ ))}+ </Box>+ )}+ </>+ ) : (+ <Box sx={{ textAlign: 'center', py: 3 }}>+ <Typography sx={{ color: theme.palette.text.secondary, mb: 1 }}>+ No system scan data available.+ </Typography>+ </Box>+ )}++ <Box sx={{ display: 'flex', justifyContent: 'flex-end' }}>+ <Button+ size="small"+ startIcon={scanning ? <CircularProgress size={14} /> : <RefreshIcon />}+ onClick={runScan}+ disabled={scanning}+ >+ {scanResult ? 'Rescan' : 'Scan System'}+ </Button>+ </Box>+ </SettingGroup>++ {/* Dependencies */}+ <SettingGroup title="Dependencies">+ {dependencies.length === 0 ? (+ <Box sx={{ textAlign: 'center', py: 3 }}>+ <Typography sx={{ color: theme.palette.text.secondary, mb: 1 }}>+ No dependency data loaded.+ </Typography>+ <Button size="small" startIcon={<RefreshIcon />} onClick={detectDeps}>+ Check Dependencies+ </Button>+ </Box>+ ) : (+ <>+ {dependencies.filter(d => d.required).length > 0 && (+ <Box sx={{ mb: 2 }}>+ <Typography variant="caption" sx={{ fontWeight: 700, color: theme.palette.text.secondary, mb: 0.5, display: 'block' }}>+ REQUIRED+ </Typography>+ {dependencies.filter(d => d.required).map(dep => (+ <DependencyRow+ key={dep.id}+ dep={dep}+ isInstalling={installing === dep.id}+ onInstall={() => installDep(dep.id)}+ />+ ))}+ </Box>+ )}+ {dependencies.filter(d => !d.required).length > 0 && (+ <Box>+ <Typography variant="caption" sx={{ fontWeight: 700, color: theme.palette.text.secondary, mb: 0.5, display: 'block' }}>+ OPTIONAL+ </Typography>+ {dependencies.filter(d => !d.required).map(dep => (+ <DependencyRow+ key={dep.id}+ dep={dep}+ isInstalling={installing === dep.id}+ onInstall={() => installDep(dep.id)}+ />+ ))}+ </Box>+ )}+ <Box sx={{ display: 'flex', justifyContent: 'flex-end', mt: 1 }}>+ <Button size="small" startIcon={<RefreshIcon />} onClick={detectDeps}>+ Recheck All+ </Button>+ </Box>+ </>+ )}+ </SettingGroup>+ </>+ );+}++function DependencyRow({ dep, isInstalling, onInstall }: { dep: DependencyInfo; isInstalling: boolean; onInstall: () => void }) {+ const theme = useTheme();+ const canInstall = dep.status === 'missing' || dep.status === 'outdated';+ const isCuda = dep.id === 'cuda';++ return (+ <Paper+ elevation={0}+ sx={{+ p: 1.5, mb: 0.5,+ border: `1px solid ${theme.palette.divider}`,+ borderRadius: 1,+ display: 'flex',+ alignItems: 'center',+ gap: 1.5,+ }}+ >+ <DependencyStatusIcon status={isInstalling ? 'installing' : dep.status} />+ <Box sx={{ flex: 1, minWidth: 0 }}>+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>+ <Typography variant="body2" sx={{ fontWeight: 600 }}>+ {dep.name}+ </Typography>+ {dep.version && (+ <Chip label={dep.version} size="small" sx={{ height: 18, fontSize: '0.65rem' }} />+ )}+ {dep.required && (+ <Chip label="required" size="small" color="warning" variant="outlined" sx={{ height: 18, fontSize: '0.6rem' }} />+ )}+ </Box>+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>+ {dep.description}+ </Typography>+ {dep.error && (+ <Typography variant="caption" sx={{ display: 'block', color: theme.palette.error.main, mt: 0.25 }}>+ {dep.error}+ </Typography>+ )}+ {dep.installedPath && dep.status === 'installed' && (+ <Tooltip title={dep.installedPath}>+ <Typography+ variant="caption"+ sx={{+ display: 'block',+ color: theme.palette.text.disabled,+ fontSize: '0.6rem',+ overflow: 'hidden',+ textOverflow: 'ellipsis',+ whiteSpace: 'nowrap',+ maxWidth: 300,+ }}+ >+ {dep.installedPath}+ </Typography>+ </Tooltip>+ )}+ </Box>+ {canInstall && !isCuda && (+ <Button+ size="small"+ variant="contained"+ startIcon={isInstalling ? <CircularProgress size={14} color="inherit" /> : <DownloadIcon />}+ onClick={onInstall}+ disabled={isInstalling}+ sx={{ textTransform: 'none', fontSize: '0.75rem', whiteSpace: 'nowrap' }}+ >+ {isInstalling ? 'Installing...' : dep.status === 'outdated' ? 'Update' : 'Install'}+ </Button>+ )}+ {canInstall && isCuda && (+ <Typography variant="caption" sx={{ color: theme.palette.text.disabled, fontStyle: 'italic' }}>+ Manual install+ </Typography>+ )}+ </Paper>+ );+}++// ── Section: Raw Editor ──++function EditorSection() {+ return (+ <Box sx={{ display: 'flex', flexDirection: 'column', height: '100%' }}>+ <SectionHeader+ title="Raw Editor"+ description="View and edit all settings as JSON, YAML, or TOML. Upload a file or edit directly, then apply."+ />+ <Box sx={{ flex: 1, minHeight: 0 }}>+ <SettingsEditor />+ </Box>+ </Box>+ );+}++// ── Section Map ──++const SECTION_RENDERERS: Record<SectionId, React.FC> = {+ appearance: AppearanceSection,+ connection: ConnectionSection,+ recording: RecordingSection,+ calibration: CalibrationSection,+ mocap: MocapSection,+ vmc: VMCSection,+ system: SystemSection,+ editor: EditorSection,+};++// ── Main Settings Page ──++export const SettingsPage: React.FC = () => {+ const theme = useTheme();+ const navigate = useNavigate();+ const [activeSection, setActiveSection] = useState<SectionId>('appearance');++ const SectionContent = SECTION_RENDERERS[activeSection];++ return (+ <Box+ sx={{+ width: '100%',+ height: '100%',+ display: 'flex',+ backgroundColor: theme.palette.mode === 'dark'+ ? theme.palette.background.default+ : theme.palette.grey[50],+ overflow: 'hidden',+ }}+ >+ {/* Left navigation panel */}+ <Paper+ elevation={0}+ sx={{+ width: 240,+ minWidth: 240,+ height: '100%',+ borderRight: `1px solid ${theme.palette.divider}`,+ borderRadius: 0,+ display: 'flex',+ flexDirection: 'column',+ overflow: 'hidden',+ }}+ >+ {/* Settings header with back button */}+ <Box+ sx={{+ px: 2,+ py: 1.5,+ borderBottom: `1px solid ${theme.palette.divider}`,+ display: 'flex',+ alignItems: 'center',+ gap: 1,+ }}+ >+ <IconButton size="small" onClick={() => navigate('/')}>+ <ArrowBackIcon sx={{ fontSize: 18 }} />+ </IconButton>+ <Typography variant="h6" sx={{ fontWeight: 700, fontSize: '1.1rem' }}>+ Settings+ </Typography>+ </Box>++ {/* Section list */}+ <List+ sx={{+ flex: 1,+ overflowY: 'auto',+ py: 1,+ }}+ >+ {SECTIONS.map((section) => (+ <ListItemButton+ key={section.id}+ selected={activeSection === section.id}+ onClick={() => setActiveSection(section.id)}+ sx={{+ mx: 1,+ borderRadius: 1.5,+ mb: 0.25,+ py: 1,+ '&.Mui-selected': {+ backgroundColor: theme.palette.mode === 'dark'+ ? 'rgba(255, 255, 255, 0.08)'+ : 'rgba(0, 0, 0, 0.06)',+ '&:hover': {+ backgroundColor: theme.palette.mode === 'dark'+ ? 'rgba(255, 255, 255, 0.12)'+ : 'rgba(0, 0, 0, 0.09)',+ },+ },+ }}+ >+ <ListItemIcon sx={{ minWidth: 36, color: activeSection === section.id ? theme.palette.primary.main : theme.palette.text.secondary }}>+ {section.icon}+ </ListItemIcon>+ <ListItemText+ primary={section.label}+ primaryTypographyProps={{+ fontSize: '0.875rem',+ fontWeight: activeSection === section.id ? 600 : 400,+ }}+ />+ </ListItemButton>+ ))}+ </List>+ </Paper>++ {/* Right content area */}+ <Box+ sx={{+ flex: 1,+ height: '100%',+ overflowY: activeSection === 'editor' ? 'hidden' : 'auto',+ p: activeSection === 'editor' ? 2 : 4,+ maxWidth: activeSection === 'editor' ? undefined : 800,+ display: 'flex',+ flexDirection: 'column',+ }}+ >+ <SectionContent />+ </Box>+ </Box>+ );+};diff --git a/freemocap-ui/src/pages/WelcomePage.tsx b/freemocap-ui/src/pages/WelcomePage.tsxindex f05b03f2..d4dec084 100644--- a/freemocap-ui/src/pages/WelcomePage.tsx+++ b/freemocap-ui/src/pages/WelcomePage.tsx@@ -75,224 +75,228 @@ const WelcomePage: React.FC = () => {};return (- <Container maxWidth="md" sx={{+ <Box sx={{height: '100%',width: '100%',+ overflow: 'auto',bgcolor: theme.palette.background.default,- display: 'flex',- flexDirection: 'column',- justifyContent: 'center',- alignItems: 'center',- py: 4,- gap: 3}}>- <Fade in={true} timeout={800}>- <Paper- elevation={6}- sx={{- p: { xs: 3, sm: 5 },- display: 'flex',- flexDirection: 'column',- alignItems: 'center',- width: '100%',- backgroundColor: theme.palette.background.paper,- mx: 'auto',- borderRadius: 3,- boxShadow: theme.palette.mode === 'dark'- ? '0 8px 32px rgba(0, 0, 0, 0.5)'- : '0 8px 32px rgba(0, 0, 0, 0.1)',- overflow: 'hidden',- position: 'relative',- }}- >- {/* Background accent */}- <Box sx={{- position: 'absolute',- top: 0,- left: 0,- width: '100%',- height: '8px',- background: `linear-gradient(90deg, ${theme.palette.primary.main}, ${theme.palette.secondary.main})`,- }} />+ <Container maxWidth="md" sx={{+ minHeight: '100%',+ width: '100%',+ display: 'flex',+ flexDirection: 'column',+ justifyContent: 'center',+ alignItems: 'center',+ py: 1,+ gap: 3+ }}>+ <Fade in={true} timeout={800}>+ <Paper+ elevation={6}+ sx={{+ p: { xs: 3, sm: 5 },+ display: 'flex',+ flexDirection: 'column',+ alignItems: 'center',+ width: '100%',+ backgroundColor: theme.palette.background.paper,+ mx: 'auto',+ borderRadius: 3,+ boxShadow: theme.palette.mode === 'dark'+ ? '0 8px 32px rgba(0, 0, 0, 0.5)'+ : '0 8px 32px rgba(0, 0, 0, 0.1)',+ overflow: 'hidden',+ position: 'relative',+ }}+ >+ {/* Background accent */}+ <Box sx={{+ position: 'absolute',+ top: 0,+ left: 0,+ width: '100%',+ height: '8px',+ background: `linear-gradient(90deg, ${theme.palette.primary.main}, ${theme.palette.secondary.main})`,+ }} />++ <Grow in={true} timeout={1000}>+ <Box+ sx={{+ width: 240,+ height: 240,+ mb: 1,+ display: 'flex',+ justifyContent: 'center',+ alignItems: 'center',+ transition: 'transform 0.3s ease-in-out',+ '&:hover': {+ transform: 'scale(1.05)'+ }+ }}+ >+ {logoDataUrl && (+ <img+ src={logoDataUrl}+ alt="FreeMoCap Logo"+ style={{+ maxWidth: '100%',+ maxHeight: '100%',+ objectFit: 'contain',+ filter: theme.palette.mode === 'dark'+ ? 'drop-shadow(0 0 10px rgba(255,255,255,0.2))'+ : 'drop-shadow(0 0 10px rgba(0,0,0,0.1))'+ }}+ />+ )}+ </Box>+ </Grow>++ <Typography+ variant="h3"+ component="h1"+ gutterBottom+ sx={{+ fontWeight: 'bold',+ textAlign: 'center',+ background: theme.palette.text.primary,+ WebkitBackgroundClip: 'text',+ WebkitTextFillColor: 'transparent',+ backgroundClip: 'text',+ mb: 1+ }}+ >+ Welcome to FreeMoCap+ </Typography>++ <Typography+ variant="subtitle1"+ color="text.secondary"+ sx={{+ mb:2,+ textAlign: 'center',+ maxWidth: '80%',+ fontSize: '1.1rem'+ }}+ >+ Free and open source markerless motion capture for everyone.+ </Typography>- <Grow in={true} timeout={1000}>- <Box+ <Button+ variant="contained"+ size="large"+ onClick={handleConnectCameras}+ disabled={isConnecting}+ startIcon={isConnecting ? <CircularProgress size={20} color="inherit" /> : <VideocamIcon />}sx={{- width: 240,- height: 240,- mb: 4,- mt: 2,- display: 'flex',- justifyContent: 'center',- alignItems: 'center',- transition: 'transform 0.3s ease-in-out',+ py: 2,+ px: 6,+ fontSize: '1.2rem',+ fontWeight: 'bold',+ borderRadius: 3,+ textTransform: 'none',+ boxShadow: theme.palette.mode === 'dark'+ ? '0 4px 20px rgba(0, 0, 0, 0.5)'+ : '0 4px 20px rgba(0, 0, 0, 0.15)',+ // background: `linear-gradient(135deg, ${theme.palette.primary.main}, ${darken(theme.palette.secondary.main, 0.25)})`,+ background: darken(theme.palette.secondary.main, 0.25),+ transition: 'all 0.3s ease-in-out','&:hover': {- transform: 'scale(1.05)'+ transform: 'translateY(-2px)',+ boxShadow: theme.palette.mode === 'dark'+ ? '0 6px 24px rgba(0, 0, 0, 0.6)'+ : '0 6px 24px rgba(0, 0, 0, 0.2)',+ },+ '&:disabled': {+ background: theme.palette.action.disabledBackground,}}}>- {logoDataUrl && (- <img- src={logoDataUrl}- alt="FreeMoCap Logo"- style={{- maxWidth: '100%',- maxHeight: '100%',- objectFit: 'contain',- filter: theme.palette.mode === 'dark'- ? 'drop-shadow(0 0 10px rgba(255,255,255,0.2))'- : 'drop-shadow(0 0 10px rgba(0,0,0,0.1))'- }}- />- )}- </Box>- </Grow>+ {isConnecting ? 'Connecting...' : 'Connect Cameras'}+ </Button>- <Typography- variant="h3"- component="h1"- gutterBottom- sx={{- fontWeight: 'bold',- textAlign: 'center',- background: theme.palette.text.primary,- WebkitBackgroundClip: 'text',- WebkitTextFillColor: 'transparent',- backgroundClip: 'text',- mb: 2- }}- >- Welcome to FreeMoCap- </Typography>+ <Box component="footer" sx={{ p: 3 }}>+ <Footer />+ </Box>+ </Paper>+ </Fade>+ {/* Research Tool Disclaimer - Outside main clickable area */}+ <Paper+ elevation={1}+ sx={{+ p: 2.5,+ width: '100%',+ backgroundColor: theme.palette.mode === 'dark'+ ? 'rgba(255, 255, 255, 0.03)'+ : 'rgba(0, 0, 0, 0.02)',+ borderRadius: 2,+ }}+ ><Typography- variant="subtitle1"+ variant="body2"color="text.secondary"sx={{- mb: 4,- textAlign: 'center',- maxWidth: '80%',- fontSize: '1.1rem'- }}- >- Free and open source markerless motion capture for everyone.- </Typography>-- <Button- variant="contained"- size="large"- onClick={handleConnectCameras}- disabled={isConnecting}- startIcon={isConnecting ? <CircularProgress size={20} color="inherit" /> : <VideocamIcon />}- sx={{- mb: 3,- py: 2,- px: 6,- fontSize: '1.2rem',- fontWeight: 'bold',- borderRadius: 3,- textTransform: 'none',- boxShadow: theme.palette.mode === 'dark'- ? '0 4px 20px rgba(0, 0, 0, 0.5)'- : '0 4px 20px rgba(0, 0, 0, 0.15)',- // background: `linear-gradient(135deg, ${theme.palette.primary.main}, ${darken(theme.palette.secondary.main, 0.25)})`,- background: darken(theme.palette.secondary.main, 0.25),- transition: 'all 0.3s ease-in-out',- '&:hover': {- transform: 'translateY(-2px)',- boxShadow: theme.palette.mode === 'dark'- ? '0 6px 24px rgba(0, 0, 0, 0.6)'- : '0 6px 24px rgba(0, 0, 0, 0.2)',- },- '&:disabled': {- background: theme.palette.action.disabledBackground,+ fontSize: '0.85rem',+ lineHeight: 1.8,+ '& a': {+ color: theme.palette.mode === 'dark'+ ? theme.palette.primary.light+ : theme.palette.primary.main,+ textDecoration: 'none',+ fontWeight: 500,+ transition: 'all 0.2s',+ '&:hover': {+ textDecoration: 'underline',+ color: theme.palette.mode === 'dark'+ ? theme.palette.primary.main+ : theme.palette.primary.dark+ }}}}>- {isConnecting ? 'Connecting...' : 'Connect Cameras'}- </Button>-- <Box component="footer" sx={{ p: 3, mt: 2 }}>- <Footer />- </Box>+ FreeMoCap is currently a research and educational tool, not cleared by the FDA for clinical use. Motion capture devices are regulated under{' '}+ <MuiLink+ href="https://www.ecfr.gov/current/title-21/chapter-I/subchapter-H/part-890"+ target="_blank"+ rel="noopener noreferrer"+ onClick={(e: React.MouseEvent) => e.stopPropagation()}+ >+ 21 CFR Part 890 (Physical Medicine Devices)+ </MuiLink>+ {' '}and require{' '}+ <MuiLink+ href="https://www.fda.gov/medical-devices/premarket-submissions-selecting-and-preparing-correct-submission/premarket-notification-510k"+ target="_blank"+ rel="noopener noreferrer"+ onClick={(e: React.MouseEvent) => e.stopPropagation()}+ >+ 510(k) clearance+ </MuiLink>+ {' '}for clinical applications.+ <br />+ <br />+ <MuiLink+ href="https://aaroncherian.github.io/freemocap_validation/"+ target="_blank"+ rel="noopener noreferrer"+ onClick={(e: React.MouseEvent) => e.stopPropagation()}+ >+ - View our validation studies+ </MuiLink>+ <br />+ <MuiLink+ href="https://github.com/freemocap/freemocap_foundation/issues/32"+ target="_blank"+ rel="noopener noreferrer"+ onClick={(e: React.MouseEvent) => e.stopPropagation()}+ >+ - Join our journey towards FDA certification+ </MuiLink>+ </Typography></Paper>- </Fade>-- {/* Research Tool Disclaimer - Outside main clickable area */}- <Paper- elevation={1}- sx={{- p: 2.5,- width: '100%',- backgroundColor: theme.palette.mode === 'dark'- ? 'rgba(255, 255, 255, 0.03)'- : 'rgba(0, 0, 0, 0.02)',- borderRadius: 2,- }}- >- <Typography- variant="body2"- color="text.secondary"- sx={{- fontSize: '0.85rem',- lineHeight: 1.8,- '& a': {- color: theme.palette.mode === 'dark'- ? theme.palette.primary.light- : theme.palette.primary.main,- textDecoration: 'none',- fontWeight: 500,- transition: 'all 0.2s',- '&:hover': {- textDecoration: 'underline',- color: theme.palette.mode === 'dark'- ? theme.palette.primary.main- : theme.palette.primary.dark- }- }- }}- >- FreeMoCap is currently a research and educational tool, not cleared by the FDA for clinical use. Motion capture devices are regulated under{' '}- <MuiLink- href="https://www.ecfr.gov/current/title-21/chapter-I/subchapter-H/part-890"- target="_blank"- rel="noopener noreferrer"- onClick={(e: React.MouseEvent) => e.stopPropagation()}- >- 21 CFR Part 890 (Physical Medicine Devices)- </MuiLink>- {' '}and require{' '}- <MuiLink- href="https://www.fda.gov/medical-devices/premarket-submissions-selecting-and-preparing-correct-submission/premarket-notification-510k"- target="_blank"- rel="noopener noreferrer"- onClick={(e: React.MouseEvent) => e.stopPropagation()}- >- 510(k) clearance- </MuiLink>- {' '}for clinical applications.- <br />- <br />- <MuiLink- href="https://freemocap.github.io/documentation/validation/"- target="_blank"- rel="noopener noreferrer"- onClick={(e: React.MouseEvent) => e.stopPropagation()}- >- - View our validation studies- </MuiLink>- <br />- <MuiLink- href="https://freemocap.github.io/documentation/community/fda_pathway/"- target="_blank"- rel="noopener noreferrer"- onClick={(e: React.MouseEvent) => e.stopPropagation()}- >- - Join our journey towards FDA certification- </MuiLink>- </Typography>- </Paper>- </Container>+ </Container>+ </Box>);};diff --git a/freemocap-ui/src/services/server/ServerContextProvider.tsx b/freemocap-ui/src/services/server/ServerContextProvider.tsxindex e483e928..1a557181 100644--- a/freemocap-ui/src/services/server/ServerContextProvider.tsx+++ b/freemocap-ui/src/services/server/ServerContextProvider.tsx@@ -5,28 +5,28 @@ import {AppDispatch} from '@/store/types';import {ConnectionState, WebSocketConnection} from "@/services/server/server-helpers/websocket-connection";import {FrameProcessor} from "@/services/server/server-helpers/frame-processor/frame-processor";import {CanvasManager} from "@/services/server/server-helpers/canvas-manager";-import {backendFramerateUpdated, DetailedFramerate, frontendFramerateUpdated, logAdded, LogRecord} from '@/store';+import {+ backendFramerateUpdated,+ frontendFramerateUpdated,+ logAdded,+ serverSettingsCleared,+ serverSettingsUpdated,+} from '@/store';-import {FrameCompositor} from "@/services/server/server-helpers/frame_compositor";import {serverUrls} from "@/hooks/server-urls";-import {- CharucoObservation,- CharucoOverlayDataMessage,- CharucoOverlayDataMessageSchema-} from "@/services/server/server-helpers/image-overlay/charuco-types";-import {- MediapipeOverlayDataMessage,- MediapipeOverlayDataMessageSchema-} from "@/services/server/server-helpers/image-overlay/mediapipe-types";-import {- OverlayManager,- OverlayRendererFactory-} from "@/services/server/server-helpers/image-overlay/overlay-renderer-factory";-import {ModelInfo} from "@/services/server/server-helpers/image-overlay/image-overlay-system";+import {CharucoObservation} from "@/services/server/server-helpers/image-overlay/charuco-types";+import {OverlayManager} from "@/services/server/server-helpers/image-overlay/overlay-renderer-factory";import {MediapipeObservation} from "@/services/server/server-helpers/image-overlay/mediapipe-overlay-renderer";+import {+ arraysEqual, handleModelInfoUpdate,+ isCharucoOverlayDataMessage, isFramerateUpdate, isLogRecord, isMediapipeOverlayDataMessage,+ isSettingsStateMessage+} from "@/services/server/server-helpers/websocket-message-types";+import {RigidBodyPose} from "@/components/viewport3d/viewport3d-types";type FrameSubscriber = (bitmap: ImageBitmap) => void;type TrackedPointsSubscriber = (points: Map<string, Point3d>) => void;+type RigidBodiesSubscriber = (poses: Map<string, RigidBodyPose>) => void;export interface Point3d {x: number;@@ -36,6 +36,7 @@ export interface Point3d {export interface ServerContextValue {isConnected: boolean;+ connectionState: ConnectionState;connect: () => void;disconnect: () => void;send: (data: string | object) => void;@@ -45,88 +46,62 @@ export interface ServerContextValue {subscribeToFrames: (cameraId: string, callback: FrameSubscriber) => () => void;subscribeToTrackedPoints: (callback: TrackedPointsSubscriber) => () => void;getLatestTrackedPoints: () => Map<string, Point3d>;+ subscribeToRigidBodies: (callback: RigidBodiesSubscriber) => () => void;}export const ServerContext = createContext<ServerContextValue | null>(null);-function arraysEqual(a: string[], b: string[]): boolean {- if (a.length !== b.length) return false;- const sortedA = [...a].sort();- const sortedB = [...b].sort();- return sortedA.every((val, idx) => val === sortedB[idx]);-}--function isLogRecord(data: any): data is LogRecord {- return (- data &&- typeof data === 'object' &&- data.message_type === 'log_record' &&- typeof data.levelname === 'string' &&- typeof data.message === 'string'- );-}--interface FramerateUpdateMessage {- message_type: 'framerate_update';- camera_group_id: string;- backend_framerate: DetailedFramerate;- frontend_framerate: DetailedFramerate;-}--function isFramerateUpdate(data: any): data is FramerateUpdateMessage {- return (- data &&- typeof data === 'object' &&- data.message_type === 'framerate_update' &&- typeof data.camera_group_id === 'string' &&- data.backend_framerate &&- typeof data.backend_framerate === 'object' &&- data.frontend_framerate &&- typeof data.frontend_framerate === 'object'- );-}--function isCharucoOverlayDataMessage(data: any): data is CharucoOverlayDataMessage {- const result = CharucoOverlayDataMessageSchema.safeParse(data);- return result.success;-}-function isMediapipeOverlayDataMessage(data: any): data is MediapipeOverlayDataMessage {- const result = MediapipeOverlayDataMessageSchema.safeParse(data);- return result.success;-}--function handleModelInfoUpdate(modelInfo: ModelInfo): void {- console.log(`Received model info for tracker: ${modelInfo.tracker_name}`);- OverlayRendererFactory.setModelInfo(modelInfo.tracker_name, modelInfo);-}-export const ServerContextProvider: React.FC<{ children: ReactNode }> = ({children}) => {const dispatch = useDispatch<AppDispatch>();const [isConnected, setIsConnected] = useState<boolean>(false);+ const [connectionState, setConnectionState] = useState<ConnectionState>(ConnectionState.DISCONNECTED);const [connectedCameraIds, setConnectedCameraIds] = useState<string[]>([]);+ // Tracks the port so the WebSocket connection is recreated when it changes.+ // Updated via serverUrls.onPortChange() subscription.+ const [serverPort, setServerPort] = useState<number>(serverUrls.getPort());const wsConnectionRef = useRef<WebSocketConnection | null>(null);const frameProcessorRef = useRef<FrameProcessor | null>(null);const canvasManagerRef = useRef<CanvasManager | null>(null);const overlayManagerRef = useRef<OverlayManager | null>(null);- const frameCompositorRef = useRef<FrameCompositor | null>(null);const frameSubscribersRef = useRef<Map<string, Set<FrameSubscriber>>>(new Map());- const latestObservationsRef = useRef<Map<string, CharucoObservation|MediapipeObservation>>(new Map());+ const latestCharucoRef = useRef<Map<string, CharucoObservation>>(new Map());+ const latestMediapipeRef = useRef<Map<string, MediapipeObservation>>(new Map());const latestTrackedPoints = useRef<Map<string, Point3d>>(new Map());const trackedPointsSubscribersRef = useRef<Set<TrackedPointsSubscriber>>(new Set());+ const latestRigidBodies = useRef<Map<string, RigidBodyPose>>(new Map());+ const rigidBodiesSubscribersRef = useRef<Set<RigidBodiesSubscriber>>(new Set());+ // Subscribe to port changes from the serverUrls singleton.+ // When useElectronAPI().pythonServer.start() resolves, it calls serverUrls.setPort(),+ // which triggers this callback and causes the WebSocket to reconnect on the correct port.useEffect(() => {+ return serverUrls.onPortChange((port: number) => {+ console.log(`[ServerContext] Port changed to ${port}, will recreate WebSocket connection`);+ setServerPort(port);+ });+ }, []);++ // Create / recreate the WebSocket connection whenever the port changes.+ useEffect(() => {+ if (wsConnectionRef.current) {+ wsConnectionRef.current.disconnect();+ }+ canvasManagerRef.current?.terminateAllWorkers();+ frameProcessorRef.current?.reset();+wsConnectionRef.current = new WebSocketConnection({url: serverUrls.getWebSocketUrl(),reconnectDelay: 1000,maxReconnectAttempts: 5,- heartbeatInterval: 30000+ heartbeatInterval: 30000,+ autoConnect: true,+ autoConnectInterval: 3000,});frameProcessorRef.current = new FrameProcessor();canvasManagerRef.current = new CanvasManager();overlayManagerRef.current = new OverlayManager();- frameCompositorRef.current = new FrameCompositor();return () => {if (wsConnectionRef.current) {@@ -138,30 +113,36 @@ export const ServerContextProvider: React.FC<{ children: ReactNode }> = ({childrif (frameProcessorRef.current) {frameProcessorRef.current.reset();}- if (frameCompositorRef.current) {- frameCompositorRef.current.destroy();- }- latestObservationsRef.current.clear();+ latestCharucoRef.current.clear();+ latestMediapipeRef.current.clear();latestTrackedPoints.current.clear();trackedPointsSubscribersRef.current.clear();+ latestRigidBodies.current.clear();+ rigidBodiesSubscribersRef.current.clear();};- }, []);+ }, [serverPort]);useEffect(() => {const ws = wsConnectionRef.current;if (!ws) return;- const handleStateChange = (newState: ConnectionState): void => {+ const handleStateChange = (newState: ConnectionState, previousState: ConnectionState): void => {const connected = newState === ConnectionState.CONNECTED;+ console.log(`[WS] State transition: ${previousState} → ${newState} (connected=${connected})`);setIsConnected(connected);+ setConnectionState(newState);- if (newState === ConnectionState.DISCONNECTED || newState === ConnectionState.FAILED) {+ if (previousState === ConnectionState.CONNECTED && !connected) {+ console.log('[WS] Lost connection — clearing state');canvasManagerRef.current?.terminateAllWorkers();frameProcessorRef.current?.reset();overlayManagerRef.current?.clearAll();- latestObservationsRef.current.clear();+ latestCharucoRef.current.clear();+ latestMediapipeRef.current.clear();latestTrackedPoints.current.clear();setConnectedCameraIds([]);+ dispatch(serverSettingsCleared());+ latestRigidBodies.current.clear();}};@@ -182,8 +163,8 @@ export const ServerContextProvider: React.FC<{ children: ReactNode }> = ({childrfor (const cameraId of removedCameras) {console.log(`Removing camera ${cameraId} - not in latest payload`);canvasManagerRef.current?.terminateWorker(cameraId);- overlayManagerRef.current?.clearCamera(cameraId); // Clear overlay renderer- latestObservationsRef.current.delete(cameraId);+ latestCharucoRef.current.delete(cameraId);+ latestMediapipeRef.current.delete(cameraId);}return currentCameraIds;@@ -191,31 +172,31 @@ export const ServerContextProvider: React.FC<{ children: ReactNode }> = ({childrreturn prevIds;});- // Track remaining frames to render- let remainingFrames = frames.length;- const maxFrameNumber = Math.max(...Array.from(frameNumbers));-- const onFrameRendered = (): void => {- remainingFrames--;- if (remainingFrames === 0) {- ws.send({type: 'frameAcknowledgment', frameNumber: maxFrameNumber});- }- };+ // Acknowledge receipt immediately so the backend can prepare+ // the next frame without waiting for rendering to complete.+ if (frameNumbers.size > 0) {+ const maxFrameNumber = Math.max(...Array.from(frameNumbers));+ ws.send({type: 'frameAcknowledgment', frameNumber: maxFrameNumber});+ }- // Process frames with generic overlay managerconst overlayManager = overlayManagerRef.current!;for (const frameData of frames) {- const observation = latestObservationsRef.current.get(frameData.cameraId) || null;-- // Use generic overlay manager to composite frame- const compositeBitmap = await overlayManager.processFrame(- frameData.cameraId,- frameData.bitmap,- observation- );+ const charucoObservation = latestCharucoRef.current.get(frameData.cameraId) ?? null;+ const mediapipeObservation = latestMediapipeRef.current.get(frameData.cameraId) ?? null;++ let compositeBitmap: ImageBitmap;+ if (charucoObservation || mediapipeObservation) {+ compositeBitmap = await overlayManager.processFrame(+ frameData.cameraId,+ frameData.bitmap,+ charucoObservation,+ mediapipeObservation,+ );+ } else {+ compositeBitmap = frameData.bitmap;+ }- // Send to subscribers if any- if (frameSubscribersRef.current.size > 0) {+ {const subscribers = frameSubscribersRef.current.get(frameData.cameraId);if (subscribers && subscribers.size > 0) {for (const callback of subscribers) {@@ -225,56 +206,60 @@ export const ServerContextProvider: React.FC<{ children: ReactNode }> = ({childr}}- // Send to canvas workercanvasManagerRef.current!.sendFrameToWorker(frameData.cameraId,compositeBitmap,- onFrameRendered);}} catch (error) {console.error('Error processing frame:', error);throw error;}- }- else if (typeof event.data === 'string') {- try {- const jsonData = JSON.parse(event.data);+ } else if (typeof event.data === 'string') {+ const text = event.data;- // Handle different observation types- if (isCharucoOverlayDataMessage(jsonData)) {- for (const [cameraId, observation] of Object.entries(jsonData)) {- latestObservationsRef.current.set(cameraId, observation);- }- }- else if (isMediapipeOverlayDataMessage(jsonData)) {- for (const [cameraId, observation] of Object.entries(jsonData)) {- latestObservationsRef.current.set(cameraId, observation);- }- }- else if ('model_info' in jsonData && jsonData.model_info) {- // Handle model info updates- handleModelInfoUpdate(jsonData.model_info);- }- else if ('tracked_points3d' in jsonData) {- // Handle 3D tracked points- console.log(`Received 3d data - ${JSON.stringify(jsonData.tracked_points3d)}`);- latestTrackedPoints.current = new Map(Object.entries(jsonData.tracked_points3d));+ if (text === 'pong') {+ return;+ }+ if (text.startsWith('ping')) {+ ws.send('pong');+ return;+ }- for (const subscriber of trackedPointsSubscribersRef.current) {- subscriber(latestTrackedPoints.current);- }+ const jsonData = JSON.parse(text);++ if (isSettingsStateMessage(jsonData)) {+ console.log(`[WS] Received settings/state v${jsonData.version}`, jsonData.settings);+ dispatch(serverSettingsUpdated(jsonData));+ } else if (isCharucoOverlayDataMessage(jsonData)) {+ for (const [cameraId, observation] of Object.entries(jsonData)) {+ latestCharucoRef.current.set(cameraId, observation as CharucoObservation);}- else if (isLogRecord(jsonData)) {- dispatch(logAdded(jsonData));+ } else if (isMediapipeOverlayDataMessage(jsonData)) {+ for (const [cameraId, observation] of Object.entries(jsonData)) {+ latestMediapipeRef.current.set(cameraId, observation as MediapipeObservation);}- else if (isFramerateUpdate(jsonData)) {- dispatch(backendFramerateUpdated(jsonData.backend_framerate));- dispatch(frontendFramerateUpdated(jsonData.frontend_framerate));+ } else if ('model_info' in jsonData && jsonData.model_info) {+ handleModelInfoUpdate(jsonData.model_info);+ } else if ('tracked_points3d' in jsonData) {+ latestTrackedPoints.current = new Map(Object.entries(jsonData.tracked_points3d));+ for (const subscriber of trackedPointsSubscribersRef.current) {+ subscriber(latestTrackedPoints.current);}- } catch (error) {- console.error('Error parsing JSON message:', error);- throw error;+ } else if ('rigid_body_poses' in jsonData) {+ latestRigidBodies.current = new Map(+ Object.entries(jsonData.rigid_body_poses as Record<string, RigidBodyPose>)+ );+ for (const subscriber of rigidBodiesSubscribersRef.current) {+ subscriber(latestRigidBodies.current);+ }+ } else if (isLogRecord(jsonData)) {+ dispatch(logAdded(jsonData));+ } else if (isFramerateUpdate(jsonData)) {+ dispatch(backendFramerateUpdated(jsonData.backend_framerate));+ dispatch(frontendFramerateUpdated(jsonData.frontend_framerate));+ } else {+ console.warn('[WS] Unhandled JSON message:', Object.keys(jsonData));}}};@@ -282,14 +267,15 @@ export const ServerContextProvider: React.FC<{ children: ReactNode }> = ({childrws.on('state-change', handleStateChange);ws.on('message', handleMessage);- ws.connect();+ // Start in auto-discovery mode — silently poll until the server appears+ ws.startDiscovery();return () => {ws.off('state-change', handleStateChange);ws.off('message', handleMessage);ws.disconnect();};- }, [dispatch]);+ }, [dispatch, serverPort]);const connect = useCallback((): void => {wsConnectionRef.current?.connect();@@ -329,7 +315,6 @@ export const ServerContextProvider: React.FC<{ children: ReactNode }> = ({childrconst subscribeToTrackedPoints = useCallback((callback: TrackedPointsSubscriber): (() => void) => {trackedPointsSubscribersRef.current.add(callback);- // Immediately call with current points if any existif (latestTrackedPoints.current.size > 0) {callback(latestTrackedPoints.current);}@@ -343,9 +328,22 @@ export const ServerContextProvider: React.FC<{ children: ReactNode }> = ({childrreturn latestTrackedPoints.current;}, []);+ const subscribeToRigidBodies = useCallback((callback: RigidBodiesSubscriber): (() => void) => {+ rigidBodiesSubscribersRef.current.add(callback);++ if (latestRigidBodies.current.size > 0) {+ callback(latestRigidBodies.current);+ }++ return () => {+ rigidBodiesSubscribersRef.current.delete(callback);+ };+ }, []);+return (<ServerContext.Provider value={{isConnected,+ connectionState,connect,disconnect,send,@@ -354,9 +352,10 @@ export const ServerContextProvider: React.FC<{ children: ReactNode }> = ({childrconnectedCameraIds,subscribeToFrames,subscribeToTrackedPoints,- getLatestTrackedPoints+ getLatestTrackedPoints,+ subscribeToRigidBodies,}}>{children}</ServerContext.Provider>);-};+};\ No newline at end of filediff --git a/freemocap-ui/src/services/server/server-helpers/image-overlay/mediapipe-overlay-renderer.ts b/freemocap-ui/src/services/server/server-helpers/image-overlay/mediapipe-overlay-renderer.tsindex 5027cf9b..59d6ddbc 100644--- a/freemocap-ui/src/services/server/server-helpers/image-overlay/mediapipe-overlay-renderer.ts+++ b/freemocap-ui/src/services/server/server-helpers/image-overlay/mediapipe-overlay-renderer.ts@@ -33,17 +33,41 @@ export interface MediapipeObservation {}export class MediapipeOverlayRenderer extends BaseOverlayRenderer {- // Aspect-specific styles- private readonly bodyStyle: DrawStyle = {- pointColor: '#00FF00',+ // Body styles split by side+ private readonly bodyStyleCenter: DrawStyle = {+ pointColor: '#00AA00',pointStroke: '#008800',pointRadius: 4,- lineColor: '#00FF00',+ lineColor: 'rgba(20, 255, 20, 0.6)',lineWidth: 2,- labelColor: '#00FF00',+ labelColor: '#00AA00',labelStroke: this.TEXT_STROKE,labelFontSize: 8,- showLabels: false, // Too many points to label+ showLabels: false,+ };++ private readonly bodyStyleRight: DrawStyle = {+ pointColor: '#FF4444',+ pointStroke: '#AA0000',+ pointRadius: 4,+ lineColor: 'rgba(255, 68, 68, 0.6)',+ lineWidth: 2,+ labelColor: '#FF4444',+ labelStroke: this.TEXT_STROKE,+ labelFontSize: 8,+ showLabels: false,+ };++ private readonly bodyStyleLeft: DrawStyle = {+ pointColor: '#4488FF',+ pointStroke: '#0044AA',+ pointRadius: 4,+ lineColor: 'rgba(68, 136, 255, 0.6)',+ lineWidth: 2,+ labelColor: '#4488FF',+ labelStroke: this.TEXT_STROKE,+ labelFontSize: 8,+ showLabels: false,};private readonly rightHandStyle: DrawStyle = {@@ -124,12 +148,28 @@ export class MediapipeOverlayRenderer extends BaseOverlayRenderer {this.ctx.restore();}+ private getBodySide(name: string): 'left' | 'right' | 'center' {+ if (name.includes('left')) return 'left';+ if (name.includes('right')) return 'right';+ return 'center';+ }++ private getBodyStyleForSide(side: 'left' | 'right' | 'center'): DrawStyle {+ switch (side) {+ case 'left': return this.bodyStyleLeft;+ case 'right': return this.bodyStyleRight;+ case 'center': return this.bodyStyleCenter;+ }+ }+private drawBodyAspect(points: MediapipePoint[]): void {if (points.length === 0) return;// Create point map for segment drawingconst pointMap = new Map<string | number, Point2D>();- const point2DArray: Point2D[] = [];+ const leftPoints: Point2D[] = [];+ const rightPoints: Point2D[] = [];+ const centerPoints: Point2D[] = [];for (const point of points) {const point2D: Point2D = {@@ -139,19 +179,20 @@ export class MediapipeOverlayRenderer extends BaseOverlayRenderer {visibility: point.visibility,};pointMap.set(point.name, point2D);- point2DArray.push(point2D);- }- // Draw segments first (behind points)- if (this.modelInfo?.aspects['body']?.segment_connections) {- this.drawSegments(pointMap, this.modelInfo.aspects['body'].segment_connections, {- ...this.bodyStyle,- lineColor: 'rgba(0, 255, 0, 0.6)', // Semi-transparent- });+ const side = this.getBodySide(point.name);+ if (side === 'left') leftPoints.push(point2D);+ else if (side === 'right') rightPoints.push(point2D);+ else centerPoints.push(point2D);}- // Draw points on top- this.drawPoints(point2DArray, this.bodyStyle);+ // Draw body skeleton connections (behind points)+ this.drawBodyConnections(pointMap);++ // Draw points on top, color-coded by side+ this.drawPoints(leftPoints, this.bodyStyleLeft);+ this.drawPoints(rightPoints, this.bodyStyleRight);+ this.drawPoints(centerPoints, this.bodyStyleCenter);// Highlight key points with labelsthis.drawKeyBodyPoints(pointMap);@@ -159,24 +200,96 @@ export class MediapipeOverlayRenderer extends BaseOverlayRenderer {private drawKeyBodyPoints(pointMap: Map<string | number, Point2D>): void {// Label only important landmarks for clarity- const keyPoints = ['nose', 'left_shoulder', 'right_shoulder', 'left_hip', 'right_hip'];+ const keyPoints = ['body.nose', 'body.left_shoulder', 'body.right_shoulder', 'body.left_hip', 'body.right_hip'];for (const key of keyPoints) {const point = pointMap.get(key);if (point && this.isValidPoint(point)) {+ const style = this.getBodyStyleForSide(this.getBodySide(key));this.drawText(- key.replace('_', ' '),+ key.replace('body.', '').replace('_', ' '),point.x + 5,point.y - 5,8,- this.bodyStyle.labelColor,- this.bodyStyle.labelStroke,+ style.labelColor,+ style.labelStroke,1);}}}+ private drawBodyConnections(+ pointMap: Map<string | number, Point2D>,+ ): void {+ // Connections grouped by side for color coding+ const centerConnections = [+ ['body.nose', 'body.left_eye_inner'],+ ['body.nose', 'body.right_eye_inner'],+ ['body.mouth_left', 'body.mouth_right'],+ ['body.left_shoulder', 'body.right_shoulder'],+ ['body.left_hip', 'body.right_hip'],+ ];++ const leftConnections = [+ ['body.left_eye_inner', 'body.left_eye'],+ ['body.left_eye', 'body.left_eye_outer'],+ ['body.left_eye_outer', 'body.left_ear'],+ ['body.left_shoulder', 'body.left_hip'],+ ['body.left_shoulder', 'body.left_elbow'],+ ['body.left_elbow', 'body.left_wrist'],+ ['body.left_wrist', 'body.left_pinky'],+ ['body.left_wrist', 'body.left_index'],+ ['body.left_wrist', 'body.left_thumb'],+ ['body.left_index', 'body.left_pinky'],+ ['body.left_hip', 'body.left_knee'],+ ['body.left_knee', 'body.left_ankle'],+ ['body.left_ankle', 'body.left_heel'],+ ['body.left_heel', 'body.left_foot_index'],+ ['body.left_ankle', 'body.left_foot_index'],+ ];++ const rightConnections = [+ ['body.right_eye_inner', 'body.right_eye'],+ ['body.right_eye', 'body.right_eye_outer'],+ ['body.right_eye_outer', 'body.right_ear'],+ ['body.right_shoulder', 'body.right_hip'],+ ['body.right_shoulder', 'body.right_elbow'],+ ['body.right_elbow', 'body.right_wrist'],+ ['body.right_wrist', 'body.right_pinky'],+ ['body.right_wrist', 'body.right_index'],+ ['body.right_wrist', 'body.right_thumb'],+ ['body.right_index', 'body.right_pinky'],+ ['body.right_hip', 'body.right_knee'],+ ['body.right_knee', 'body.right_ankle'],+ ['body.right_ankle', 'body.right_heel'],+ ['body.right_heel', 'body.right_foot_index'],+ ['body.right_ankle', 'body.right_foot_index'],+ ];++ const groups: [string[][], DrawStyle][] = [+ [centerConnections, this.bodyStyleCenter],+ [leftConnections, this.bodyStyleLeft],+ [rightConnections, this.bodyStyleRight],+ ];++ for (const [connections, style] of groups) {+ for (const [start, end] of connections) {+ const startPoint = pointMap.get(start);+ const endPoint = pointMap.get(end);++ if (startPoint && endPoint && this.isValidPoint(startPoint) && this.isValidPoint(endPoint)) {+ this.ctx.strokeStyle = style.lineColor;+ this.ctx.lineWidth = style.lineWidth;+ this.ctx.beginPath();+ this.ctx.moveTo(startPoint.x, startPoint.y);+ this.ctx.lineTo(endPoint.x, endPoint.y);+ this.ctx.stroke();+ }+ }+ }+ }+private drawHandAspect(points: MediapipePoint[],aspectName: string,@@ -271,10 +384,8 @@ export class MediapipeOverlayRenderer extends BaseOverlayRenderer {this.drawPoints(point2DArray, this.faceStyle);- // Optionally draw face contour lines if we have the indices- if (this.modelInfo?.aspects['face']) {- this.drawFaceContour(points);- }+ // Draw face contour highlights for key features+ this.drawFaceContour(points);}private drawFaceContour(points: MediapipePoint[]): void {@@ -357,4 +468,4 @@ export class MediapipeOverlayRenderer extends BaseOverlayRenderer {2);}-}+}\ No newline at end of filediff --git a/freemocap-ui/src/services/server/server-helpers/image-overlay/overlay-renderer-factory.ts b/freemocap-ui/src/services/server/server-helpers/image-overlay/overlay-renderer-factory.tsindex d5a10c92..060463b3 100644--- a/freemocap-ui/src/services/server/server-helpers/image-overlay/overlay-renderer-factory.ts+++ b/freemocap-ui/src/services/server/server-helpers/image-overlay/overlay-renderer-factory.ts@@ -86,63 +86,60 @@ export class OverlayRendererFactory {}/**- * Manager for handling overlay rendering across multiple cameras+ * Manager for handling overlay rendering across multiple cameras.+ *+ * Composites both charuco and mediapipe overlays sequentially onto each+ * frame: source → charuco → mediapipe. Each renderer draws on top of+ * the previous result rather than clearing and redrawing from scratch.*/export class OverlayManager {- private renderers: Map<string, BaseOverlayRenderer> = new Map();- private observationTypeMap: Map<string, ObservationType> = new Map();+ private charucoRenderer: CharucoOverlayRenderer = new CharucoOverlayRenderer();+ private mediapipeRenderer: MediapipeOverlayRenderer = new MediapipeOverlayRenderer();/**- * Process a frame with overlay+ * Composite both overlay types onto a single frame, chained sequentially.+ * The charuco overlay is drawn first, then mediapipe on top of the result.*/public async processFrame(cameraId: string,sourceBitmap: ImageBitmap,- observation: CharucoObservation | MediapipeObservation | null+ charucoObservation: CharucoObservation | null,+ mediapipeObservation: MediapipeObservation | null,): Promise<ImageBitmap> {- // Determine observation type- const observationType = observation?.message_type as ObservationType;+ let currentBitmap = sourceBitmap;- if (!observationType && !observation) {- // No observation, just return the source bitmap- return sourceBitmap;+ if (charucoObservation) {+ currentBitmap = await this.charucoRenderer.compositeFrame(+ currentBitmap,+ charucoObservation,+ );}- // Get or create renderer for this camera- let renderer = this.renderers.get(cameraId);- const previousType = this.observationTypeMap.get(cameraId);-- // Check if we need a different renderer type- if (!renderer || previousType !== observationType) {- renderer = OverlayRendererFactory.getRenderer(observationType);- this.renderers.set(cameraId, renderer);- this.observationTypeMap.set(cameraId, observationType);+ if (mediapipeObservation) {+ currentBitmap = await this.mediapipeRenderer.compositeFrame(+ currentBitmap,+ mediapipeObservation,+ );}- // Process the frame- return renderer.compositeFrame(sourceBitmap, observation);+ return currentBitmap;}/**- * Clear renderer for a specific camera+ * Set model info on both renderers*/- public clearCamera(cameraId: string): void {- const renderer = this.renderers.get(cameraId);- if (renderer) {- renderer.destroy();- this.renderers.delete(cameraId);- this.observationTypeMap.delete(cameraId);- }+ public setModelInfo(modelInfo: ModelInfo): void {+ this.charucoRenderer.setModelInfo(modelInfo);+ this.mediapipeRenderer.setModelInfo(modelInfo);}/*** Clear all renderers*/public clearAll(): void {- for (const renderer of this.renderers.values()) {- renderer.destroy();- }- this.renderers.clear();- this.observationTypeMap.clear();+ this.charucoRenderer.destroy();+ this.mediapipeRenderer.destroy();+ this.charucoRenderer = new CharucoOverlayRenderer();+ this.mediapipeRenderer = new MediapipeOverlayRenderer();}-}+}\ No newline at end of filediff --git a/freemocap-ui/src/services/server/server-helpers/websocket-connection.ts b/freemocap-ui/src/services/server/server-helpers/websocket-connection.tsindex c2813d86..45a99752 100644--- a/freemocap-ui/src/services/server/server-helpers/websocket-connection.ts+++ b/freemocap-ui/src/services/server/server-helpers/websocket-connection.ts@@ -3,17 +3,38 @@ export interface WebSocketConfig {reconnectDelay?: number;maxReconnectAttempts?: number;heartbeatInterval?: number;+ /** When true, silently poll for the server and auto-connect when it appears. */+ autoConnect?: boolean;+ /** Polling interval (ms) when in auto-connect discovery mode. */+ autoConnectInterval?: number;}export enum ConnectionState {+ /** Idle — not trying to connect. */DISCONNECTED = 'DISCONNECTED',+ /** Actively opening a WebSocket connection. */CONNECTING = 'CONNECTING',+ /** WebSocket is open. */CONNECTED = 'CONNECTED',+ /** Lost connection, attempting to re-establish. */RECONNECTING = 'RECONNECTING',- FAILED = 'FAILED'+ /** Silently polling for the server to become available. */+ DISCOVERING = 'DISCOVERING',}-type EventCallback = (...args: any[]) => void;+/** Typed event map — each key declares its callback signature. */+interface WebSocketEventMap {+ 'state-change': (newState: ConnectionState, previousState: ConnectionState) => void;+ 'message': (event: MessageEvent) => void;+ 'open': () => void;+ 'close': (event: CloseEvent) => void;+ 'error': (event: Event) => void;+ 'send-failed': (data: string | object) => void;+ 'send-error': (error: unknown) => void;+ 'max-reconnect-attempts': () => void;+}++type EventName = keyof WebSocketEventMap;export class WebSocketConnection {private ws: WebSocket | null = null;@@ -21,50 +42,62 @@ export class WebSocketConnection {private reconnectAttempts: number = 0;private reconnectTimer: number | null = null;private heartbeatTimer: number | null = null;+ private discoveryTimer: number | null = null;private state: ConnectionState = ConnectionState.DISCONNECTED;- // Simple event emitter implementation for browser- private listeners: Map<string, Set<EventCallback>> = new Map();+ private listeners: { [K in EventName]?: Set<WebSocketEventMap[K]> } = {};constructor(config: WebSocketConfig) {this.config = {reconnectDelay: config.reconnectDelay ?? 1000,maxReconnectAttempts: config.maxReconnectAttempts ?? 5,heartbeatInterval: config.heartbeatInterval ?? 30000,- url: config.url+ autoConnect: config.autoConnect ?? false,+ autoConnectInterval: config.autoConnectInterval ?? 3000,+ url: config.url,};}- public on(event: string, callback: EventCallback): void {- if (!this.listeners.has(event)) {- this.listeners.set(event, new Set());+ public on<K extends EventName>(event: K, callback: WebSocketEventMap[K]): void {+ if (!this.listeners[event]) {+ // eslint-disable-next-line @typescript-eslint/no-explicit-any+ this.listeners[event] = new Set() as any;}- this.listeners.get(event)!.add(callback);+ // eslint-disable-next-line @typescript-eslint/no-explicit-any+ (this.listeners[event] as any).add(callback);}- public off(event: string, callback: EventCallback): void {- this.listeners.get(event)?.delete(callback);+ public off<K extends EventName>(event: K, callback: WebSocketEventMap[K]): void {+ // eslint-disable-next-line @typescript-eslint/no-explicit-any+ (this.listeners[event] as any)?.delete(callback);}- private emit(event: string, ...args: any[]): void {- this.listeners.get(event)?.forEach(callback => {+ private emit<K extends EventName>(event: K, ...args: Parameters<WebSocketEventMap[K]>): void {+ const set = this.listeners[event];+ if (!set) return;+ for (const callback of set) {try {- callback(...args);+ // eslint-disable-next-line @typescript-eslint/no-explicit-any+ (callback as any)(...args);} catch (error) {console.error(`Error in event listener for ${event}:`, error);}- });+ }}+ /**+ * Begin actively trying to open the WebSocket connection.+ * If autoConnect is enabled and the attempt fails, falls back to discovery mode.+ */public connect(): void {if (this.state === ConnectionState.CONNECTING || this.state === ConnectionState.CONNECTED) {return;}+ this.stopDiscovery();this.setState(ConnectionState.CONNECTING);try {- console.log(`Connecting to WebSocket at ${this.config.url}`);this.ws = new WebSocket(this.config.url);this.ws.binaryType = 'arraybuffer';@@ -77,12 +110,15 @@ export class WebSocketConnection {}}+ /**+ * Cleanly close the connection and stop all reconnection/discovery.+ */public disconnect(): void {this.clearTimers();+ this.stopDiscovery();this.reconnectAttempts = 0;if (this.ws) {- // Remove handlers to avoid reconnection on closethis.ws.onclose = null;this.ws.close();this.ws = null;@@ -91,9 +127,22 @@ export class WebSocketConnection {this.setState(ConnectionState.DISCONNECTED);}+ /**+ * Enter discovery mode: silently poll for the server at a fixed interval.+ * Does not surface errors — just keeps trying until the server appears.+ */+ public startDiscovery(): void {+ if (this.state === ConnectionState.CONNECTED || this.state === ConnectionState.CONNECTING) {+ return;+ }++ console.log(`[WS] Entering discovery mode (polling every ${this.config.autoConnectInterval}ms)`);+ this.setState(ConnectionState.DISCOVERING);+ this.scheduleDiscoveryAttempt();+ }+public send(data: string | object): boolean {if (!this.isConnected()) {- console.warn('WebSocket not connected, queuing message');this.emit('send-failed', data);return false;}@@ -117,6 +166,10 @@ export class WebSocketConnection {return this.state;}+ // -----------------------------------------------------------+ // Private+ // -----------------------------------------------------------+private setState(state: ConnectionState): void {const previousState = this.state;this.state = state;@@ -126,6 +179,7 @@ export class WebSocketConnection {private handleOpen(): void {console.log('WebSocket connected');this.reconnectAttempts = 0;+ this.stopDiscovery();this.setState(ConnectionState.CONNECTED);this.startHeartbeat();this.emit('open');@@ -134,24 +188,32 @@ export class WebSocketConnection {private handleClose(event: CloseEvent): void {console.log(`WebSocket closed: code=${event.code}, reason=${event.reason}`);this.clearTimers();+ this.ws = null;- const wasConnected = this.state === ConnectionState.CONNECTED;+ // Always transition to DISCONNECTED first — this triggers cleanup+ // in listeners (e.g. ServerContextProvider dispatches serverSettingsCleared)+ this.setState(ConnectionState.DISCONNECTED);+ this.emit('close', event);- if (wasConnected && this.reconnectAttempts < this.config.maxReconnectAttempts) {+ // If autoConnect is on, immediately start polling for the server again+ if (this.config.autoConnect) {+ this.startDiscovery();+ return;+ }++ if (this.reconnectAttempts < this.config.maxReconnectAttempts) {this.scheduleReconnect();- } else if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {- this.setState(ConnectionState.FAILED);- this.emit('max-reconnect-attempts');} else {- this.setState(ConnectionState.DISCONNECTED);+ this.emit('max-reconnect-attempts');}-- this.emit('close', event);}- private handleError(error: Event): void {- console.error('WebSocket error:', error);- this.emit('error', error);+ private handleError(_error: Event): void {+ // In discovery mode, errors are expected and silenced+ if (this.state === ConnectionState.DISCOVERING) {+ return;+ }+ this.emit('error', _error);}private handleMessage(event: MessageEvent): void {@@ -164,7 +226,7 @@ export class WebSocketConnection {this.setState(ConnectionState.RECONNECTING);const delay = Math.min(this.config.reconnectDelay * Math.pow(2, this.reconnectAttempts),- 10000 // Max 10 seconds+ 10000,);console.log(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts + 1}/${this.config.maxReconnectAttempts})`);@@ -176,10 +238,67 @@ export class WebSocketConnection {}, delay);}+ /**+ * Schedule one discovery probe. On failure, schedule the next one.+ * On success, handleOpen() takes over.+ */+ private scheduleDiscoveryAttempt(): void {+ if (this.discoveryTimer !== null) return;++ this.discoveryTimer = window.setTimeout(() => {+ this.discoveryTimer = null;++ if (this.state !== ConnectionState.DISCOVERING) return;++ try {+ const probe = new WebSocket(this.config.url);+ probe.binaryType = 'arraybuffer';++ probe.onopen = () => {+ console.log('[WS] Discovery probe succeeded — promoting to main connection');+ // Discovery succeeded — promote this socket to the main connection+ this.ws = probe;+ probe.onclose = this.handleClose.bind(this);+ probe.onerror = this.handleError.bind(this);+ probe.onmessage = this.handleMessage.bind(this);+ this.handleOpen();+ };++ probe.onerror = () => {+ // Silently swallow — try again on the next interval+ try { probe.close(); } catch { /* ignore */ }+ if (this.state === ConnectionState.DISCOVERING) {+ this.scheduleDiscoveryAttempt();+ }+ };++ probe.onclose = () => {+ // If we get a close without ever opening, try again+ if (this.state === ConnectionState.DISCOVERING) {+ this.scheduleDiscoveryAttempt();+ }+ };+ } catch {+ // WebSocket constructor threw — try again+ if (this.state === ConnectionState.DISCOVERING) {+ this.scheduleDiscoveryAttempt();+ }+ }+ }, this.config.autoConnectInterval);+ }++ private stopDiscovery(): void {+ if (this.discoveryTimer !== null) {+ clearTimeout(this.discoveryTimer);+ this.discoveryTimer = null;+ }+ }+private startHeartbeat(): void {this.heartbeatTimer = window.setInterval(() => {if (this.isConnected()) {- this.send({type: 'ping'});+ // Send plain text "ping" — the backend expects this format+ this.ws!.send('ping');}}, this.config.heartbeatInterval);}diff --git a/freemocap-ui/src/services/server/server-helpers/websocket-message-types.ts b/freemocap-ui/src/services/server/server-helpers/websocket-message-types.tsnew file mode 100644index 00000000..eb1e424d--- /dev/null+++ b/freemocap-ui/src/services/server/server-helpers/websocket-message-types.ts@@ -0,0 +1,76 @@+import {DetailedFramerate, LogRecord} from '@/store';+import {SettingsStateMessage} from '@/store/slices/settings/settings-types';+import {+ CharucoOverlayDataMessage,+ CharucoOverlayDataMessageSchema,+} from "@/services/server/server-helpers/image-overlay/charuco-types";+import {+ MediapipeOverlayDataMessage,+ MediapipeOverlayDataMessageSchema,+} from "@/services/server/server-helpers/image-overlay/mediapipe-types";+import {ModelInfo} from "@/services/server/server-helpers/image-overlay/image-overlay-system";+import {OverlayRendererFactory} from "@/services/server/server-helpers/image-overlay/overlay-renderer-factory";++export interface FramerateUpdateMessage {+ message_type: 'framerate_update';+ camera_group_id: string;+ backend_framerate: DetailedFramerate;+ frontend_framerate: DetailedFramerate;+}++export function arraysEqual(a: string[], b: string[]): boolean {+ if (a.length !== b.length) return false;+ const sortedA = [...a].sort();+ const sortedB = [...b].sort();+ return sortedA.every((val, idx) => val === sortedB[idx]);+}++export function isLogRecord(data: unknown): data is LogRecord {+ return (+ typeof data === 'object' &&+ data !== null &&+ (data as Record<string, unknown>).message_type === 'log_record' &&+ typeof (data as Record<string, unknown>).levelname === 'string' &&+ typeof (data as Record<string, unknown>).message === 'string'+ );+}++export function isSettingsStateMessage(data: unknown): data is SettingsStateMessage {+ return (+ typeof data === 'object' &&+ data !== null &&+ (data as Record<string, unknown>).message_type === 'settings/state' &&+ typeof (data as Record<string, unknown>).settings === 'object' &&+ (data as Record<string, unknown>).settings !== null &&+ typeof (data as Record<string, unknown>).version === 'number'+ );+}++export function isFramerateUpdate(data: unknown): data is FramerateUpdateMessage {+ const d = data as Record<string, unknown>;+ return (+ typeof data === 'object' &&+ data !== null &&+ d.message_type === 'framerate_update' &&+ typeof d.camera_group_id === 'string' &&+ typeof d.backend_framerate === 'object' &&+ d.backend_framerate !== null &&+ typeof d.frontend_framerate === 'object' &&+ d.frontend_framerate !== null+ );+}++export function isCharucoOverlayDataMessage(data: unknown): data is CharucoOverlayDataMessage {+ const result = CharucoOverlayDataMessageSchema.safeParse(data);+ return result.success;+}++export function isMediapipeOverlayDataMessage(data: unknown): data is MediapipeOverlayDataMessage {+ const result = MediapipeOverlayDataMessageSchema.safeParse(data);+ return result.success;+}++export function handleModelInfoUpdate(modelInfo: ModelInfo): void {+ console.log(`Received model info for tracker: ${modelInfo.tracker_name}`);+ OverlayRendererFactory.setModelInfo(modelInfo.tracker_name, modelInfo);+}\ No newline at end of filediff --git a/freemocap-ui/src/store/index.ts b/freemocap-ui/src/store/index.tsindex c1da4ad5..c57b7807 100644--- a/freemocap-ui/src/store/index.ts+++ b/freemocap-ui/src/store/index.ts@@ -12,3 +12,4 @@ export * from './slices/theme';export * from './slices/videos';export * from './slices/pipeline';export * from './slices/mocap';+export * from './slices/settings';diff --git a/freemocap-ui/src/store/slices/calibration/calibration-slice.ts b/freemocap-ui/src/store/slices/calibration/calibration-slice.tsindex 8fbe1c37..65124964 100644--- a/freemocap-ui/src/store/slices/calibration/calibration-slice.ts+++ b/freemocap-ui/src/store/slices/calibration/calibration-slice.ts@@ -1,4 +1,3 @@-// store/slices/calibration/calibration-slice.tsimport {createSelector, createSlice, PayloadAction} from '@reduxjs/toolkit';import {RootState} from '../../types';import {@@ -10,6 +9,8 @@ import {// ==================== Types ====================+export type CalibrationSolverMethod = 'anipose' | 'pyceres';+export interface CalibrationConfig {liveTrackCharuco: boolean;charucoBoardXSquares: number;@@ -17,12 +18,14 @@ export interface CalibrationConfig {charucoSquareLength: number;minSharedViewsPerCamera: number;autoStopOnMinViewCount: boolean;+ solverMethod: CalibrationSolverMethod;+ useGroundplane: boolean;}export interface CalibrationDirectoryInfo {exists: boolean;- canRecord: boolean; // true if directory doesn't exist OR exists but is empty- canCalibrate: boolean; // true if has videos (either in synchronized_videos or root)+ canRecord: boolean;+ canCalibrate: boolean;cameraCalibrationTomlPath: string | null;hasSynchronizedVideos: boolean;hasVideos: boolean;@@ -35,9 +38,9 @@ export interface CalibrationState {recordingProgress: number;isLoading: boolean;error: string | null;- lastCalibrationRecordingPath: string | null; // Path from last recording- manualCalibrationRecordingPath: string | null; // User-selected override path- directoryInfo: CalibrationDirectoryInfo | null; // Info about the current calibration directory+ lastCalibrationRecordingPath: string | null;+ manualCalibrationRecordingPath: string | null;+ directoryInfo: CalibrationDirectoryInfo | null;}// ==================== Initial State ====================@@ -50,6 +53,8 @@ const initialState: CalibrationState = {charucoSquareLength: 1,minSharedViewsPerCamera: 200,autoStopOnMinViewCount: true,+ solverMethod: 'anipose',+ useGroundplane: false,},isRecording: false,recordingProgress: 0,@@ -78,17 +83,14 @@ export const calibrationSlice = createSlice({state.error = null;},- // New action to set manual pathmanualCalibrationRecordingPathChanged: (state, action: PayloadAction<string>) => {state.manualCalibrationRecordingPath = action.payload;},- // New action to clear manual path (revert to default)manualCalibrationRecordingPathCleared: (state) => {state.manualCalibrationRecordingPath = null;},- // New action to update directory infocalibrationDirectoryInfoUpdated: (state, action: PayloadAction<CalibrationDirectoryInfo>) => {state.directoryInfo = action.payload;},@@ -97,7 +99,6 @@ export const calibrationSlice = createSlice({},extraReducers: (builder) => {- // Start Recordingbuilder.addCase(startCalibrationRecording.pending, (state) => {state.isLoading = true;@@ -107,7 +108,6 @@ export const calibrationSlice = createSlice({state.isLoading = false;state.isRecording = true;state.recordingProgress = 0;- // Store the path returned from the serverif (action.payload.calibrationRecordingPath) {state.lastCalibrationRecordingPath = action.payload.calibrationRecordingPath;}@@ -117,7 +117,6 @@ export const calibrationSlice = createSlice({state.error = action.payload || 'Failed to start recording';});- // Stop Recordingbuilder.addCase(stopCalibrationRecording.pending, (state) => {state.isLoading = true;@@ -133,7 +132,6 @@ export const calibrationSlice = createSlice({state.error = action.payload || 'Failed to stop recording';});- // Calibrate Recordingbuilder.addCase(calibrateRecording.pending, (state) => {state.isLoading = true;@@ -147,7 +145,6 @@ export const calibrationSlice = createSlice({state.error = action.payload || 'Failed to calibrate recording';});- // Update Config on Serverbuilder.addCase(updateCalibrationConfigOnServer.rejected, (state, action) => {state.error = action.payload || 'Failed to sync config to server';@@ -175,13 +172,11 @@ export const selectCalibrationRecordingPath = createSelector(if (manualPath) return manualPath;if (lastPath) return lastPath;- // Build calibration path from recording computed valuesconst calibrationFolderName = `${recordingComputed.recordingName}_calibration`;return `${recordingComputed.fullRecordingPath}/${calibrationFolderName}`;});-// Selector to check if using manual pathexport const selectIsUsingManualCalibrationPath = createSelector([(state: RootState) => state.calibration.manualCalibrationRecordingPath],(manualPath) => manualPath !== null@@ -195,7 +190,6 @@ export const selectCanStartCalibrationRecording = createSelector(selectCalibrationDirectoryInfo],(isRecording, isLoading, recordingPath, directoryInfo) => {- // Can start if: not recording, not loading, have a path, and directory can be recorded toreturn !isRecording && !isLoading && !!recordingPath && (directoryInfo?.canRecord ?? true);});@@ -208,7 +202,6 @@ export const selectCanCalibrate = createSelector(selectCalibrationDirectoryInfo],(calibrationPath, isLoading, isRecording, directoryInfo) => {- // Can calibrate if: have path, not loading, not recording, and directory has videosreturn !!calibrationPath && !isLoading && !isRecording && (directoryInfo?.canCalibrate ?? false);});@@ -225,6 +218,4 @@ export const {resetCalibrationState} = calibrationSlice.actions;-// ==================== Reducer Export ====================-export default calibrationSlice.reducer;diff --git a/freemocap-ui/src/store/slices/calibration/calibration-thunks.ts b/freemocap-ui/src/store/slices/calibration/calibration-thunks.tsindex ea23bdc4..eaddc923 100644--- a/freemocap-ui/src/store/slices/calibration/calibration-thunks.ts+++ b/freemocap-ui/src/store/slices/calibration/calibration-thunks.ts@@ -2,61 +2,7 @@ import {createAsyncThunk} from "@reduxjs/toolkit";import {RootState} from "@/store";import {serverUrls} from "@/hooks/server-urls";import {selectCalibrationRecordingPath} from "./calibration-slice";--// Helper function to extract detailed error info from failed responses-async function getDetailedErrorMessage(response: Response): Promise<string> {- let errorDetails: unknown;-- try {- // Try to parse JSON error response- errorDetails = await response.json();- console.error('❌ Server returned validation/error details:', errorDetails);- } catch {- // If not JSON, try to get text- try {- errorDetails = await response.text();- console.error('❌ Server returned error text:', errorDetails);- } catch {- console.error('❌ Could not read error response body');- }- }-- // Build comprehensive error message- const baseError = `HTTP ${response.status}: ${response.statusText}`;-- if (errorDetails) {- // Pretty print the error details- const detailsStr = typeof errorDetails === 'string'- ? errorDetails- : JSON.stringify(errorDetails, null, 2);- return `${baseError}\n\nValidation/Error Details:\n${detailsStr}`;- }-- return baseError;-}--// Helper function to generate calibration recording name based on recording config-function generateCalibrationRecordingName(state: RootState): string {- const recordingConfig = state.recording.config;- const parts: string[] = [];-- // Add base name if configured- if (recordingConfig.baseName && recordingConfig.baseName !== 'recording') {- parts.push(recordingConfig.baseName);- }-- const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);- parts.push(timestamp);-- // Add recording tag if provided- if (recordingConfig.recordingTag) {- parts.push(recordingConfig.recordingTag);- }-- parts.push('calibration');-- return parts.join('_');-}+import {getDetailedErrorMessage} from "@/store/slices/thunk-helpers";export const startCalibrationRecording = createAsyncThunk<{ success: boolean; message?: string; calibrationRecordingPath?: string },diff --git a/freemocap-ui/src/store/slices/cameras/cameras-slice.ts b/freemocap-ui/src/store/slices/cameras/cameras-slice.tsindex 0b35f593..b0691567 100644--- a/freemocap-ui/src/store/slices/cameras/cameras-slice.ts+++ b/freemocap-ui/src/store/slices/cameras/cameras-slice.ts@@ -1,8 +1,8 @@-// cameras-slice.tsimport {createSlice, PayloadAction} from '@reduxjs/toolkit';import {areConfigsEqual, CameraConfig, CamerasState, extractConfigSettings,} from './cameras-types';import {detectCameras,} from './cameras-thunks';import {closePipeline, connectRealtimePipeline} from '../pipeline/pipeline-thunks';+import {serverSettingsCleared, serverSettingsUpdated} from '../settings/settings-slice';const initialState: CamerasState = {@@ -25,7 +25,6 @@ export const cameraSlice = createSlice({},// ========== Configuration ==========- // User updates desired configcameraDesiredConfigUpdated: (state,action: PayloadAction<{@@ -38,7 +37,6 @@ export const cameraSlice = createSlice({);if (camera) {camera.desiredConfig = {...camera.desiredConfig, ...action.payload.config};- // Check if there's now a mismatchcamera.hasConfigMismatch = !areConfigsEqual(camera.actualConfig, camera.desiredConfig);}},@@ -47,7 +45,6 @@ export const cameraSlice = createSlice({const sourceCamera = state.cameras.find(cam => cam.id === action.payload);if (!sourceCamera) return;- // Extract copyable settings (exclude identity fields)const settings = extractConfigSettings(sourceCamera.desiredConfig);state.cameras.forEach(camera => {@@ -78,14 +75,13 @@ export const cameraSlice = createSlice({state.error = action.error.message || 'Failed to detect cameras';})- // ========== Connect Pipeline ==========+ // ========== Connect Pipeline (HTTP) ==========.addCase(connectRealtimePipeline.pending, (state) => {state.isLoading = true;state.error = null;}).addCase(connectRealtimePipeline.fulfilled, (state, action) => {state.isLoading = false;- // Update camera actual configs from server responseObject.entries(action.payload.camera_configs).forEach(([cameraId, config]) => {const camera = state.cameras.find(cam => cam.id === cameraId);@@ -102,13 +98,42 @@ export const cameraSlice = createSlice({state.error = action.error.message || 'Failed to connect to cameras';})- // ========== Close Pipeline ==========+ // ========== Close Pipeline (HTTP) ==========.addCase(closePipeline.fulfilled, (state) => {state.cameras.forEach(camera => {camera.connectionStatus = 'available';camera.metrics = undefined;camera.hasConfigMismatch = false;});+ })++ // ========== WebSocket settings/state — sync camera connection status ==========+ .addCase(serverSettingsUpdated, (state, action) => {+ const backendCameras = action.payload.settings.cameras;+ for (const camera of state.cameras) {+ const backendCam = backendCameras[camera.id];+ if (backendCam) {+ // Sync connection status from authoritative backend state+ if (backendCam.status === 'connected') {+ camera.connectionStatus = 'connected';+ } else if (backendCam.status === 'error') {+ camera.connectionStatus = 'error';+ } else {+ camera.connectionStatus = 'available';+ }+ } else {+ // Backend doesn't know about this camera — it's not connected+ camera.connectionStatus = 'available';+ }+ }+ })++ // ========== WebSocket disconnected — clear all connected state ==========+ .addCase(serverSettingsCleared, (state) => {+ state.cameras.forEach(camera => {+ camera.connectionStatus = 'available';+ camera.metrics = undefined;+ });});},});diff --git a/freemocap-ui/src/store/slices/cameras/cameras-types.ts b/freemocap-ui/src/store/slices/cameras/cameras-types.tsindex 880d5e44..a7455fec 100644--- a/freemocap-ui/src/store/slices/cameras/cameras-types.ts+++ b/freemocap-ui/src/store/slices/cameras/cameras-types.ts@@ -1,4 +1,4 @@-// cameras-types.ts+// cameras-viewport3d-types.tsimport {z} from 'zod';// ==================== Constants ====================diff --git a/freemocap-ui/src/store/slices/framerate/framerate-types.ts b/freemocap-ui/src/store/slices/framerate/framerate-types.tsindex 780cbb4e..48819b03 100644--- a/freemocap-ui/src/store/slices/framerate/framerate-types.ts+++ b/freemocap-ui/src/store/slices/framerate/framerate-types.ts@@ -1,4 +1,4 @@-// framerate-types.ts+// framerate-viewport3d-types.tsimport {z} from 'zod';// The actual framerate data structure used in the Redux storediff --git a/freemocap-ui/src/store/slices/mocap/mocap-slice.ts b/freemocap-ui/src/store/slices/mocap/mocap-slice.tsindex 053b3a80..3309db49 100644--- a/freemocap-ui/src/store/slices/mocap/mocap-slice.ts+++ b/freemocap-ui/src/store/slices/mocap/mocap-slice.ts@@ -1,4 +1,3 @@-// store/slices/mocap/mocap-slice.tsimport {createSelector, createSlice, PayloadAction} from '@reduxjs/toolkit';import {RootState} from '../../types';import {@@ -10,13 +9,124 @@ import {// ==================== Types ====================+/**+ * Mirrors skellytracker MediapipeModelComplexity enum.+ * 0 = LITE (fastest), 1 = FULL (balanced), 2 = HEAVY (most accurate)+ */+export type MediapipeModelComplexity = 0 | 1 | 2;++/**+ * Mirrors skellytracker MediapipeDetectorConfig.+ * Field names use snake_case to match the backend JSON.+ */+export interface MediapipeDetectorConfig {+ model_complexity: MediapipeModelComplexity;+ min_detection_confidence: number;+ min_tracking_confidence: number;+ confidence_threshold: number;+ static_image_mode: boolean;+ smooth_landmarks: boolean;+ enable_segmentation: boolean;+ smooth_segmentation: boolean;+ refine_face_landmarks: boolean;+}++/**+ * Mirrors backend EstimatorConfig (bone length estimation tuning).+ */+export interface EstimatorConfig {+ max_samples: number;+ min_samples_for_full_confidence: number;+ iqr_confidence_sensitivity: number;+}++/**+ * Mirrors backend RealtimeFilterConfig (skeleton smoothing + gating).+ * Field names use snake_case to match the backend JSON.+ */+export interface RealtimeFilterConfig {+ // One Euro Filter params+ min_cutoff: number;+ beta: number;+ d_cutoff: number;+ // FABRIK params+ fabrik_tolerance: number;+ fabrik_max_iterations: number;+ // Bone length estimation params+ height_meters: number;+ noise_sigma: number;+ estimator_config: EstimatorConfig;+ // Point gate params+ max_reprojection_error_px: number;+ max_velocity_m_per_s: number;+ max_rejected_streak: number;+ // Prediction params+ max_prediction_frames: number;+ prediction_velocity_decay: number;+}++/**+ * Mirrors backend MocapPipelineConfig.+ */export interface MocapConfig {+ detector: MediapipeDetectorConfig;+ skeleton_filter: RealtimeFilterConfig;}+/** Realtime preset matching MEDIAPIPE_TRACKER_REALTIME_PRESET on the backend. */+export const MEDIAPIPE_REALTIME_PRESET: MediapipeDetectorConfig = {+ model_complexity: 0,+ min_detection_confidence: 0.5,+ min_tracking_confidence: 0.5,+ confidence_threshold: 0.5,+ static_image_mode: false,+ smooth_landmarks: true,+ enable_segmentation: false,+ smooth_segmentation: false,+ refine_face_landmarks: true,+};++/** Posthoc preset matching MEDIAPIPE_TRACKER_POSTHOC_PRESET on the backend. */+export const MEDIAPIPE_POSTHOC_PRESET: MediapipeDetectorConfig = {+ model_complexity: 2,+ min_detection_confidence: 0.5,+ min_tracking_confidence: 0.5,+ confidence_threshold: 0.5,+ static_image_mode: false,+ smooth_landmarks: true,+ enable_segmentation: true,+ smooth_segmentation: true,+ refine_face_landmarks: true,+};++/** Default EstimatorConfig matching backend defaults. */+export const DEFAULT_ESTIMATOR_CONFIG: EstimatorConfig = {+ max_samples: 500,+ min_samples_for_full_confidence: 100,+ iqr_confidence_sensitivity: 10.0,+};++/** Default RealtimeFilterConfig matching backend defaults. */+export const DEFAULT_REALTIME_FILTER_CONFIG: RealtimeFilterConfig = {+ min_cutoff: 0.005,+ beta: 0.3,+ d_cutoff: 1.0,+ fabrik_tolerance: 1e-4,+ fabrik_max_iterations: 20,+ height_meters: 1.75,+ noise_sigma: 0.015,+ estimator_config: { ...DEFAULT_ESTIMATOR_CONFIG },+ max_reprojection_error_px: 60.0,+ max_velocity_m_per_s: 50.0,+ max_rejected_streak: 5,+ max_prediction_frames: 15,+ prediction_velocity_decay: 0.75,+};+export interface MocapDirectoryInfo {exists: boolean;- canRecord: boolean; // true if directory doesn't exist OR exists but is empty- canCalibrate: boolean; // true if has videos (either in synchronized_videos or root)+ canRecord: boolean;+ canCalibrate: boolean;cameraMocapTomlPath: string | null;hasSynchronizedVideos: boolean;hasVideos: boolean;@@ -29,21 +139,17 @@ export interface MocapState {recordingProgress: number;isLoading: boolean;error: string | null;- lastMocapRecordingPath: string | null; // Path from last recording- manualMocapRecordingPath: string | null; // User-selected override path- directoryInfo: MocapDirectoryInfo | null; // Info about the current mocap directory+ lastMocapRecordingPath: string | null;+ manualMocapRecordingPath: string | null;+ directoryInfo: MocapDirectoryInfo | null;}// ==================== Initial State ====================const initialState: MocapState = {config: {- liveTrackCharuco: true,- charucoBoardXSquares: 5,- charucoBoardYSquares: 3,- charucoSquareLength: 1,- minSharedViewsPerCamera: 200,- autoStopOnMinViewCount: true,+ detector: { ...MEDIAPIPE_REALTIME_PRESET },+ skeleton_filter: { ...DEFAULT_REALTIME_FILTER_CONFIG },},isRecording: false,recordingProgress: 0,@@ -60,8 +166,24 @@ export const mocapSlice = createSlice({name: 'mocap',initialState,reducers: {- mocapConfigUpdated: (state, action: PayloadAction<Partial<MocapConfig>>) => {- state.config = { ...state.config, ...action.payload };+ /** Replace the entire detector config (e.g. applying a preset). */+ mocapDetectorConfigReplaced: (state, action: PayloadAction<MediapipeDetectorConfig>) => {+ state.config.detector = action.payload;+ },++ /** Partially update individual detector fields. */+ mocapDetectorConfigUpdated: (state, action: PayloadAction<Partial<MediapipeDetectorConfig>>) => {+ state.config.detector = { ...state.config.detector, ...action.payload };+ },++ /** Replace the entire skeleton filter config. */+ skeletonFilterConfigReplaced: (state, action: PayloadAction<RealtimeFilterConfig>) => {+ state.config.skeleton_filter = action.payload;+ },++ /** Partially update individual skeleton filter fields. */+ skeletonFilterConfigUpdated: (state, action: PayloadAction<Partial<RealtimeFilterConfig>>) => {+ state.config.skeleton_filter = { ...state.config.skeleton_filter, ...action.payload };},mocapProgressUpdated: (state, action: PayloadAction<number>) => {@@ -72,17 +194,14 @@ export const mocapSlice = createSlice({state.error = null;},- // New action to set manual pathmanualMocapRecordingPathChanged: (state, action: PayloadAction<string>) => {state.manualMocapRecordingPath = action.payload;},- // New action to clear manual path (revert to default)manualMocapRecordingPathCleared: (state) => {state.manualMocapRecordingPath = null;},- // New action to update directory infomocapDirectoryInfoUpdated: (state, action: PayloadAction<MocapDirectoryInfo>) => {state.directoryInfo = action.payload;},@@ -91,7 +210,6 @@ export const mocapSlice = createSlice({},extraReducers: (builder) => {- // Start Recordingbuilder.addCase(startMocapRecording.pending, (state) => {state.isLoading = true;@@ -101,7 +219,6 @@ export const mocapSlice = createSlice({state.isLoading = false;state.isRecording = true;state.recordingProgress = 0;- // Store the path returned from the serverif (action.payload.mocapRecordingPath) {state.lastMocapRecordingPath = action.payload.mocapRecordingPath;}@@ -111,7 +228,6 @@ export const mocapSlice = createSlice({state.error = action.payload || 'Failed to start recording';});- // Stop Recordingbuilder.addCase(stopMocapRecording.pending, (state) => {state.isLoading = true;@@ -127,7 +243,6 @@ export const mocapSlice = createSlice({state.error = action.payload || 'Failed to stop recording';});- // Process Mocap Recordingbuilder.addCase(processMocapRecording.pending, (state) => {state.isLoading = true;@@ -138,10 +253,9 @@ export const mocapSlice = createSlice({}).addCase(processMocapRecording.rejected, (state, action) => {state.isLoading = false;- state.error = action.payload || 'Failed to calibrate recording';+ state.error = action.payload || 'Failed to process recording';});- // Update Config on Serverbuilder.addCase(updateMocapConfigOnServer.rejected, (state, action) => {state.error = action.payload || 'Failed to sync config to server';@@ -153,6 +267,8 @@ export const mocapSlice = createSlice({export const selectMocap = (state: RootState) => state.mocap;export const selectMocapConfig = (state: RootState) => state.mocap.config;+export const selectMocapDetectorConfig = (state: RootState) => state.mocap.config.detector;+export const selectSkeletonFilterConfig = (state: RootState) => state.mocap.config.skeleton_filter;export const selectMocapIsLoading = (state: RootState) => state.mocap.isLoading;export const selectMocapIsRecording = (state: RootState) => state.mocap.isRecording;export const selectMocapProgress = (state: RootState) => state.mocap.recordingProgress;@@ -169,13 +285,11 @@ export const selectMocapRecordingPath = createSelector(if (manualPath) return manualPath;if (lastPath) return lastPath;- // Build mocap path from recording computed valuesconst mocapFolderName = `${recordingComputed.recordingName}_mocap`;return `${recordingComputed.fullRecordingPath}/${mocapFolderName}`;});-// Selector to check if using manual pathexport const selectIsUsingManualMocapPath = createSelector([(state: RootState) => state.mocap.manualMocapRecordingPath],(manualPath) => manualPath !== null@@ -189,7 +303,6 @@ export const selectCanStartMocapRecording = createSelector(selectMocapDirectoryInfo],(isRecording, isLoading, recordingPath, directoryInfo) => {- // Can start if: not recording, not loading, have a path, and directory can be recorded toreturn !isRecording && !isLoading && !!recordingPath && (directoryInfo?.canRecord ?? true);});@@ -202,7 +315,6 @@ export const selectCanProcessMocapRecording = createSelector(selectMocapDirectoryInfo],(mocapPath, isLoading, isRecording, directoryInfo) => {- // Can process if: have path, not loading, not recording, and directory has videosreturn !!mocapPath && !isLoading && !isRecording && (directoryInfo?.canCalibrate ?? false);});@@ -210,7 +322,10 @@ export const selectCanProcessMocapRecording = createSelector(// ==================== Actions Export ====================export const {- mocapConfigUpdated,+ mocapDetectorConfigReplaced,+ mocapDetectorConfigUpdated,+ skeletonFilterConfigReplaced,+ skeletonFilterConfigUpdated,mocapProgressUpdated,mocapErrorCleared,manualMocapRecordingPathChanged,@@ -219,6 +334,4 @@ export const {resetMocapState} = mocapSlice.actions;-// ==================== Reducer Export ====================-export default mocapSlice.reducer;diff --git a/freemocap-ui/src/store/slices/mocap/mocap-thunks.ts b/freemocap-ui/src/store/slices/mocap/mocap-thunks.tsindex ad2665a6..9785476c 100644--- a/freemocap-ui/src/store/slices/mocap/mocap-thunks.ts+++ b/freemocap-ui/src/store/slices/mocap/mocap-thunks.ts@@ -2,61 +2,7 @@ import {createAsyncThunk} from "@reduxjs/toolkit";import {RootState} from "@/store";import {serverUrls} from "@/hooks/server-urls";import {selectMocapRecordingPath} from "./mocap-slice";--// Helper function to extract detailed error info from failed responses-async function getDetailedErrorMessage(response: Response): Promise<string> {- let errorDetails: unknown;-- try {- // Try to parse JSON error response- errorDetails = await response.json();- console.error('❌ Server returned validation/error details:', errorDetails);- } catch {- // If not JSON, try to get text- try {- errorDetails = await response.text();- console.error('❌ Server returned error text:', errorDetails);- } catch {- console.error('❌ Could not read error response body');- }- }-- // Build comprehensive error message- const baseError = `HTTP ${response.status}: ${response.statusText}`;-- if (errorDetails) {- // Pretty print the error details- const detailsStr = typeof errorDetails === 'string'- ? errorDetails- : JSON.stringify(errorDetails, null, 2);- return `${baseError}\n\nValidation/Error Details:\n${detailsStr}`;- }-- return baseError;-}--// Helper function to generate mocap recording name based on recording config-function generateMocapRecordingName(state: RootState): string {- const recordingConfig = state.recording.config;- const parts: string[] = [];-- // Add base name if configured- if (recordingConfig.baseName && recordingConfig.baseName !== 'recording') {- parts.push(recordingConfig.baseName);- }-- const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);- parts.push(timestamp);-- // Add recording tag if provided- if (recordingConfig.recordingTag) {- parts.push(recordingConfig.recordingTag);- }-- parts.push('mocap');-- return parts.join('_');-}+import {getDetailedErrorMessage} from "@/store/slices/thunk-helpers";export const startMocapRecording = createAsyncThunk<{ success: boolean; message?: string; mocapRecordingPath?: string },diff --git a/freemocap-ui/src/store/slices/pipeline/pipeline-slice.ts b/freemocap-ui/src/store/slices/pipeline/pipeline-slice.tsindex 4466a78c..c8ab05c8 100644--- a/freemocap-ui/src/store/slices/pipeline/pipeline-slice.ts+++ b/freemocap-ui/src/store/slices/pipeline/pipeline-slice.ts@@ -1,6 +1,7 @@import {createSlice} from "@reduxjs/toolkit";import {PipelineState} from "@/store/slices/pipeline/pipeline-types";import {closePipeline, connectRealtimePipeline} from "@/store/slices/pipeline/pipeline-thunks";+import {serverSettingsCleared, serverSettingsUpdated} from "@/store/slices/settings/settings-slice";const initialState: PipelineState = {cameraGroupId: null,@@ -14,7 +15,6 @@ export const pipelineSlice = createSlice({name: 'pipeline',initialState,reducers: {- // Manual state resetpipelineStateReset: (state) => {state.cameraGroupId = null;state.pipelineId = null;@@ -25,7 +25,7 @@ export const pipelineSlice = createSlice({},extraReducers: (builder) => {builder- // Connect Pipeline+ // ========== Connect Pipeline (HTTP) ==========.addCase(connectRealtimePipeline.pending, (state) => {state.isLoading = true;state.error = null;@@ -41,8 +41,8 @@ export const pipelineSlice = createSlice({state.error = action.error.message || 'Failed to connect pipeline';})- // disconnect pipeline- .addCase(closePipeline.pending, (state) => {+ // ========== Close Pipeline (HTTP) ==========+ .addCase(closePipeline.pending, (state) => {state.isLoading = true;state.error = null;})@@ -55,6 +55,26 @@ export const pipelineSlice = createSlice({.addCase(closePipeline.rejected, (state, action) => {state.isLoading = false;state.error = action.error.message || 'Failed to disconnect pipeline';+ })++ // ========== WebSocket settings/state — sync pipeline status ==========+ .addCase(serverSettingsUpdated, (state, action) => {+ const backendPipeline = action.payload.settings.pipeline;+ // Only overwrite if not mid-HTTP-request (isLoading guards against races)+ if (!state.isLoading) {+ state.isConnected = backendPipeline.is_connected;+ state.pipelineId = backendPipeline.pipeline_id;+ state.cameraGroupId = backendPipeline.camera_group_id;+ }+ })++ // ========== WebSocket disconnected — clear pipeline state ==========+ .addCase(serverSettingsCleared, (state) => {+ state.cameraGroupId = null;+ state.pipelineId = null;+ state.isConnected = false;+ state.isLoading = false;+ state.error = null;});},});diff --git a/freemocap-ui/src/store/slices/settings/index.ts b/freemocap-ui/src/store/slices/settings/index.tsnew file mode 100644index 00000000..1d68c6f4--- /dev/null+++ b/freemocap-ui/src/store/slices/settings/index.ts@@ -0,0 +1,3 @@+export * from "./settings-slice";+export * from "./settings-selectors";+export * from "./settings-types";diff --git a/freemocap-ui/src/store/slices/settings/settings-selectors.ts b/freemocap-ui/src/store/slices/settings/settings-selectors.tsnew file mode 100644index 00000000..e22616d6--- /dev/null+++ b/freemocap-ui/src/store/slices/settings/settings-selectors.ts@@ -0,0 +1,116 @@+import {createSelector} from "@reduxjs/toolkit";+import {RootState} from "@/store/types";+import {+ BackendCalibrationConfig,+ BackendCalibrationSettings,+ BackendCameraState,+ BackendMocapConfig,+ BackendMocapSettings,+ BackendPipelineSettings,+ FreeMoCapSettings,+} from "./settings-types";++// ---------------------------------------------------------------------------+// Root selectors+// ---------------------------------------------------------------------------++export const selectServerSettings = (state: RootState): FreeMoCapSettings | null =>+ state.settings.settings;++export const selectServerSettingsVersion = (state: RootState): number =>+ state.settings.version;++export const selectServerSettingsInitialized = (state: RootState): boolean =>+ state.settings.isInitialized;++// ---------------------------------------------------------------------------+// Camera selectors+// ---------------------------------------------------------------------------++export const selectBackendCameras = createSelector(+ [selectServerSettings],+ (settings): Record<string, BackendCameraState> => settings?.cameras ?? {},+);++export const selectBackendCameraIds = createSelector(+ [selectBackendCameras],+ (cameras): string[] => Object.keys(cameras),+);++export const selectBackendConnectedCameraCount = createSelector(+ [selectBackendCameras],+ (cameras): number =>+ Object.values(cameras).filter((c) => c.status === "connected").length,+);++// ---------------------------------------------------------------------------+// Pipeline selectors+// ---------------------------------------------------------------------------++export const selectBackendPipeline = createSelector(+ [selectServerSettings],+ (settings): BackendPipelineSettings | null => settings?.pipeline ?? null,+);++export const selectBackendPipelineIsConnected = createSelector(+ [selectBackendPipeline],+ (pipeline): boolean => pipeline?.is_connected ?? false,+);++export const selectBackendPipelineId = createSelector(+ [selectBackendPipeline],+ (pipeline): string | null => pipeline?.pipeline_id ?? null,+);++// ---------------------------------------------------------------------------+// Calibration selectors+// ---------------------------------------------------------------------------++export const selectBackendCalibration = createSelector(+ [selectServerSettings],+ (settings): BackendCalibrationSettings | null => settings?.calibration ?? null,+);++export const selectBackendCalibrationConfig = createSelector(+ [selectBackendCalibration],+ (cal): BackendCalibrationConfig | null => cal?.config ?? null,+);++export const selectBackendCalibrationIsRecording = createSelector(+ [selectBackendCalibration],+ (cal): boolean => cal?.is_recording ?? false,+);++export const selectBackendCalibrationProgress = createSelector(+ [selectBackendCalibration],+ (cal): number => cal?.recording_progress ?? 0,+);++export const selectBackendHasCalibrationToml = createSelector(+ [selectBackendCalibration],+ (cal): boolean => cal?.has_calibration_toml ?? false,+);++// ---------------------------------------------------------------------------+// MoCap selectors+// ---------------------------------------------------------------------------++export const selectBackendMocap = createSelector(+ [selectServerSettings],+ (settings): BackendMocapSettings | null => settings?.mocap ?? null,+);++export const selectBackendMocapConfig = createSelector(+ [selectBackendMocap],+ (moc): BackendMocapConfig | null => moc?.config ?? null,+);++export const selectBackendMocapIsRecording = createSelector(+ [selectBackendMocap],+ (moc): boolean => moc?.is_recording ?? false,+);++export const selectBackendMocapProgress = createSelector(+ [selectBackendMocap],+ (moc): number => moc?.recording_progress ?? 0,+);diff --git a/freemocap-ui/src/store/slices/settings/settings-slice.ts b/freemocap-ui/src/store/slices/settings/settings-slice.tsnew file mode 100644index 00000000..ba661a4c--- /dev/null+++ b/freemocap-ui/src/store/slices/settings/settings-slice.ts@@ -0,0 +1,52 @@+import {createSlice, PayloadAction} from "@reduxjs/toolkit";+import {FreeMoCapSettings, SettingsStateMessage} from "./settings-types";++export interface ServerSettingsState {+ settings: FreeMoCapSettings | null;+ version: number;+ lastUpdated: string | null;+ isInitialized: boolean;+}++const initialState: ServerSettingsState = {+ settings: null,+ version: -1,+ lastUpdated: null,+ isInitialized: false,+};++export const settingsSlice = createSlice({+ name: "serverSettings",+ initialState,+ reducers: {+ /**+ * Replace the entire settings blob from a backend settings/state message.+ * Only applies if the incoming version is newer than what we have.+ */+ serverSettingsUpdated: (state, action: PayloadAction<SettingsStateMessage>) => {+ const {settings, version} = action.payload;+ if (version <= state.version) {+ return; // Stale message — ignore+ }+ state.settings = settings;+ state.version = version;+ state.lastUpdated = new Date().toISOString();+ state.isInitialized = true;+ },++ /**+ * Reset to initial state (e.g., on WebSocket disconnect).+ */+ serverSettingsCleared: (state) => {+ state.settings = null;+ state.version = -1;+ state.lastUpdated = null;+ state.isInitialized = false;+ },+ },+});++export const {+ serverSettingsUpdated,+ serverSettingsCleared,+} = settingsSlice.actions;diff --git a/freemocap-ui/src/store/slices/settings/settings-types.ts b/freemocap-ui/src/store/slices/settings/settings-types.tsnew file mode 100644index 00000000..f81ef937--- /dev/null+++ b/freemocap-ui/src/store/slices/settings/settings-types.ts@@ -0,0 +1,174 @@+/**+ * TypeScript types mirroring the backend FreeMoCapSettings Pydantic models.+ *+ * These represent the authoritative backend state pushed over WebSocket.+ * Field names use snake_case to match the JSON the backend sends.+ */++// ---------------------------------------------------------------------------+// Camera layer (mirrors skellycam CameraConfig + runtime status)+// ---------------------------------------------------------------------------++export interface BackendImageResolution {+ height: number;+ width: number;+}++export interface BackendCameraConfig {+ camera_id: string;+ camera_index: number;+ camera_name: string;+ use_this_camera: boolean;+ resolution: BackendImageResolution;+ color_channels: number;+ pixel_format: string;+ exposure_mode: string;+ exposure: number;+ framerate: number;+ rotation: number;+ capture_fourcc: string;+ writer_fourcc: string;+}++export type BackendCameraStatus = "disconnected" | "connected" | "error";++export interface BackendCameraState {+ config: BackendCameraConfig;+ status: BackendCameraStatus;+}++// ---------------------------------------------------------------------------+// Calibration config (mirrors CalibrationPipelineConfig)+// ---------------------------------------------------------------------------++export type CalibrationSolverMethod = "anipose" | "pyceres";++export interface BackendCalibrationConfig {+ calibration_recording_folder: string | null;+ charuco_board_x_squares: number;+ charuco_board_y_squares: number;+ charuco_square_length: number;+ solver_method: CalibrationSolverMethod;+ use_groundplane: boolean;+ pyceres_solver_config: Record<string, unknown>;+}++export interface BackendCalibrationSettings {+ config: BackendCalibrationConfig;+ is_recording: boolean;+ recording_progress: number;+ last_recording_path: string | null;+ has_calibration_toml: boolean;+}++// ---------------------------------------------------------------------------+// MoCap config (mirrors MocapPipelineConfig)+// ---------------------------------------------------------------------------++export interface BackendEstimatorConfig {+ max_samples: number;+ min_samples_for_full_confidence: number;+ iqr_confidence_sensitivity: number;+}++export interface BackendRealtimeFilterConfig {+ min_cutoff: number;+ beta: number;+ d_cutoff: number;+ fabrik_tolerance: number;+ fabrik_max_iterations: number;+ height_meters: number;+ noise_sigma: number;+ estimator_config: BackendEstimatorConfig;+ max_reprojection_error_px: number;+ max_velocity_m_per_s: number;+ max_rejected_streak: number;+ max_prediction_frames: number;+ prediction_velocity_decay: number;+}++export interface BackendMocapConfig {+ detector: Record<string, unknown>;+ skeleton_filter: BackendRealtimeFilterConfig;+}++export interface BackendMocapSettings {+ config: BackendMocapConfig;+ is_recording: boolean;+ recording_progress: number;+ last_recording_path: string | null;+}++// ---------------------------------------------------------------------------+// Pipeline config (mirrors RealtimePipelineConfig + runtime status)+// ---------------------------------------------------------------------------++export interface BackendRealtimePipelineConfig {+ camera_configs: Record<string, BackendCameraConfig>;+ calibration_config: BackendCalibrationConfig;+ mocap_config: BackendMocapConfig;+ calibration_detection_enabled: boolean;+ mocap_detection_enabled: boolean;+}++export interface BackendPipelineSettings {+ config: BackendRealtimePipelineConfig | null;+ is_connected: boolean;+ pipeline_id: string | null;+ camera_group_id: string | null;+ is_paused: boolean;+}++// ---------------------------------------------------------------------------+// VMC settings (mirrors VMCSettings)+// ---------------------------------------------------------------------------++export interface BackendVMCSettings {+ enabled: boolean;+ host: string;+ port: number;+}++// ---------------------------------------------------------------------------+// Top-level settings blob+// ---------------------------------------------------------------------------++export interface FreeMoCapSettings {+ cameras: Record<string, BackendCameraState>;+ pipeline: BackendPipelineSettings;+ calibration: BackendCalibrationSettings;+ mocap: BackendMocapSettings;+ vmc: BackendVMCSettings;+}++// ---------------------------------------------------------------------------+// WebSocket message types+// ---------------------------------------------------------------------------++export interface SettingsStateMessage {+ message_type: "settings/state";+ settings: FreeMoCapSettings;+ version: number;+}++export interface SettingsPatchMessage {+ message_type: "settings/patch";+ patch: DeepPartial<FreeMoCapSettings>;+}++export interface SettingsRequestMessage {+ message_type: "settings/request";+}++export type SettingsMessage =+ | SettingsStateMessage+ | SettingsPatchMessage+ | SettingsRequestMessage;++// ---------------------------------------------------------------------------+// Utility: deep partial for patch payloads+// ---------------------------------------------------------------------------++export type DeepPartial<T> = {+ [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];+};diff --git a/freemocap-ui/src/store/slices/thunk-helpers.ts b/freemocap-ui/src/store/slices/thunk-helpers.tsnew file mode 100644index 00000000..f6b9fc8a--- /dev/null+++ b/freemocap-ui/src/store/slices/thunk-helpers.ts@@ -0,0 +1,35 @@+/**+ * Shared utilities for async thunks that call the backend HTTP API.+ */++/**+ * Extract a detailed error message from a failed HTTP response.+ * Attempts to parse JSON first, falls back to text, builds a+ * comprehensive error string including status code and body.+ */+export async function getDetailedErrorMessage(response: Response): Promise<string> {+ let errorDetails: unknown;++ try {+ errorDetails = await response.json();+ console.error('❌ Server returned validation/error details:', errorDetails);+ } catch {+ try {+ errorDetails = await response.text();+ console.error('❌ Server returned error text:', errorDetails);+ } catch {+ console.error('❌ Could not read error response body');+ }+ }++ const baseError = `HTTP ${response.status}: ${response.statusText}`;++ if (errorDetails) {+ const detailsStr = typeof errorDetails === 'string'+ ? errorDetails+ : JSON.stringify(errorDetails, null, 2);+ return `${baseError}\n\nValidation/Error Details:\n${detailsStr}`;+ }++ return baseError;+}diff --git a/freemocap-ui/src/store/store.ts b/freemocap-ui/src/store/store.tsindex 1f289268..c5dd136d 100644--- a/freemocap-ui/src/store/store.ts+++ b/freemocap-ui/src/store/store.ts@@ -8,6 +8,7 @@ import {logRecordsSlice} from "./slices/log-records/log-records-slice";import {pipelineSlice} from "./slices/pipeline/pipeline-slice";import {calibrationSlice} from "@/store/slices/calibration/calibration-slice";import {mocapSlice} from "@/store/slices/mocap/mocap-slice";+import {settingsSlice} from "@/store/slices/settings/settings-slice";export const store = configureStore({reducer: {@@ -20,7 +21,6 @@ export const store = configureStore({pipeline: pipelineSlice.reducer,calibration: calibrationSlice.reducer,mocap: mocapSlice.reducer,- }+ settings: settingsSlice.reducer,+ },});--diff --git a/freemocap-ui/vite.config.ts b/freemocap-ui/vite.config.tsindex 07031ab9..c7758adc 100644--- a/freemocap-ui/vite.config.ts+++ b/freemocap-ui/vite.config.ts@@ -23,7 +23,6 @@ export default defineConfig(({command}) => {react(),electron({main: {- // Shortcut of `build.lib.entry`entry: 'electron/main/index.ts',onstart(args) {if (process.env.VSCODE_DEBUG) {@@ -38,18 +37,19 @@ export default defineConfig(({command}) => {minify: isBuild,outDir: 'dist-electron/main',rollupOptions: {- external: Object.keys('dependencies' in pkg ? pkg.dependencies : {}),+ external: [+ ...Object.keys('dependencies' in pkg ? pkg.dependencies : {}),+ 'electron-devtools-installer',+ ],},},},},preload: {- // Shortcut of `build.rollupOptions.input`.- // Preload scripts may contain Web assets, so use the `build.rollupOptions.input` instead `build.lib.entry`.input: 'electron/preload/index.ts',vite: {build: {- sourcemap: sourcemap ? 'inline' : undefined, // #332+ sourcemap: sourcemap ? 'inline' : undefined,minify: isBuild,outDir: 'dist-electron/preload',rollupOptions: {@@ -58,26 +58,20 @@ export default defineConfig(({command}) => {},},},- // Ployfill the Electron and Node.js API for Renderer process.- // If you want use Node.js in Renderer process, the `nodeIntegration` needs to be enabled in the Main process.- // See 👉 https://github.com/electron-vite/vite-plugin-electron-rendererrenderer: {},}),],optimizeDeps: {exclude: ["@ffmpeg/ffmpeg", "@ffmpeg/util"],},- server: process.env.VSCODE_DEBUG && (() => {- const url = new URL(pkg.debug.env.VITE_DEV_SERVER_URL)- return {- host: url.hostname,- port: +url.port,- headers: {- "Cross-Origin-Opener-Policy": "same-origin",- "Cross-Origin-Embedder-Policy": "require-corp",- },- }- })(),+ server: {+ host: '127.0.0.1',+ port: 7877,+ headers: {+ "Cross-Origin-Opener-Policy": "same-origin",+ "Cross-Origin-Embedder-Policy": "require-corp",+ },+ },clearScreen: false,}})diff --git a/freemocap-ui/vitest.config.ts b/freemocap-ui/vitest.config.tsnew file mode 100644index 00000000..24dce78d--- /dev/null+++ b/freemocap-ui/vitest.config.ts@@ -0,0 +1,16 @@+/// <reference types="vitest" />+import { defineConfig } from 'vite';+import path from 'path';++export default defineConfig({+ test: {+ globals: true,+ environment: 'node',+ include: ['src/**/*.test.ts', 'src/**/*.test.tsx'],+ },+ resolve: {+ alias: {+ '@': path.resolve(__dirname, './src'),+ },+ },+});diff --git a/freemocap/.idea/workspace.xml b/freemocap/.idea/workspace.xmldeleted file mode 100644index d2775a3e..00000000--- a/freemocap/.idea/workspace.xml+++ /dev/null@@ -1,48 +0,0 @@-<?xml version="1.0" encoding="UTF-8"?>-<project version="4">- <component name="AutoImportSettings">- <option name="autoReloadType" value="SELECTIVE" />- </component>- <component name="ChangeListManager">- <list default="true" id="664e9f86-ca5f-498e-a2a6-51de9dcdf5f5" name="Changes" comment="">- <change afterPath="$PROJECT_DIR$/icon_support.py" afterDir="false" />- <change beforePath="$PROJECT_DIR$/../bin/installer.sh" beforeDir="false" afterPath="$PROJECT_DIR$/../bin/installer.sh" afterDir="false" />- <change beforePath="$PROJECT_DIR$/__init__.py" beforeDir="false" afterPath="$PROJECT_DIR$/__init__.py" afterDir="false" />- <change beforePath="$PROJECT_DIR$/__main__.py" beforeDir="false" afterPath="$PROJECT_DIR$/__main__.py" afterDir="false" />- <change beforePath="$PROJECT_DIR$/gui/qt/freemocap_main.py" beforeDir="false" afterPath="$PROJECT_DIR$/gui/qt/freemocap_main.py" afterDir="false" />- <change beforePath="$PROJECT_DIR$/../pyproject.toml" beforeDir="false" afterPath="$PROJECT_DIR$/../pyproject.toml" afterDir="false" />- <change beforePath="$PROJECT_DIR$/../src/gui/main/main.py" beforeDir="false" />- </list>- <option name="SHOW_DIALOG" value="false" />- <option name="HIGHLIGHT_CONFLICTS" value="true" />- <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />- <option name="LAST_RESOLUTION" value="IGNORE" />- </component>- <component name="Git.Settings">- <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$/.." />- </component>- <component name="ProjectId" id="2Q7DQUROvd4MGSbQZemEdrlKZQ8" />- <component name="ProjectViewState">- <option name="hideEmptyMiddlePackages" value="true" />- <option name="showLibraryContents" value="true" />- </component>- <component name="PropertiesComponent">{- "keyToString": {- "RunOnceActivity.OpenProjectViewOnStart": "true",- "RunOnceActivity.ShowReadmeOnStart": "true",- "git-widget-placeholder": "main",- "last_opened_file_path": "/Users/jon/github_repos/freemocap_organization/freemocap/freemocap"- }-}</component>- <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />- <component name="TaskManager">- <task active="true" id="Default" summary="Default task">- <changelist id="664e9f86-ca5f-498e-a2a6-51de9dcdf5f5" name="Changes" comment="" />- <created>1684695709495</created>- <option name="number" value="Default" />- <option name="presentableId" value="Default" />- <updated>1684695709495</updated>- </task>- <servers />- </component>-</project>\ No newline at end of filediff --git a/freemocap/__init__.py b/freemocap/__init__.pyindex 4019a2e0..52f54c82 100644--- a/freemocap/__init__.py+++ b/freemocap/__init__.py@@ -9,8 +9,11 @@ __package_name__ = "freemocap"__repo_url__ = f"https://github.com/freemocap/{__package_name__}/"__repo_issues_url__ = f"{__repo_url__}issues"+import time+tik = time.perf_counter()from freemocap.system.logging_configuration.configure_logging import configure_loggingfrom freemocap.system.logging_configuration.log_levels import LogLevelsLOG_LEVEL = LogLevels.TRACEconfigure_logging(LOG_LEVEL)+diff --git a/freemocap/__main__.py b/freemocap/__main__.pyindex be33e35a..10454770 100644--- a/freemocap/__main__.py+++ b/freemocap/__main__.py@@ -1,60 +1,80 @@import asyncioimport loggingimport multiprocessing+import osimport signal-import sys--import uvicorn-from skellycam.utilities.kill_process_on_port import kill_process_on_port-from skellycam.utilities.wait_functions import await_1s--from freemocap.api.server_constants import HOSTNAME, PORT-from freemocap.app.app import create_fastapi_applogger = logging.getLogger(__name__)async def main() -> None:- # Create shared kill flag for subprocesses- global_kill_flag: multiprocessing.Value = multiprocessing.Value("b", False)- heartbeat_timestamp:multiprocessing.Value = multiprocessing.Value("d", 0)- subprocess_registry: list[multiprocessing.Process] = []+ # Heavy imports are here (not at module level) so that multiprocessing+ # child processes don't re-import the entire app tree on Windows.+ # Windows uses the `spawn` start method, which re-executes this file+ # in every child process — but only `main()` needs these imports,+ # and children never call `main()`.+ import uvicorn+ from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry+ from skellycam.core.ipc.process_management.managed_worker import WorkerMode+ from skellycam.utilities.kill_process_on_port import kill_process_on_port+ from skellycam.utilities.wait_functions import await_1s++ from freemocap.api.server_constants import (+ HOSTNAME,+ find_available_port,+ format_port_sentinel,+ )+ from freemocap.app.app import create_fastapi_app++ port = find_available_port()++ # Print the port sentinel to stdout so the Electron main process can discover it.+ # flush=True ensures it arrives immediately even when stdout is buffered.+ print(format_port_sentinel(port=port), flush=True)++ global_kill_flag = multiprocessing.Value("b", False)+ worker_registry = WorkerRegistry(+ global_kill_flag=global_kill_flag,+ worker_mode=WorkerMode.PROCESS+ )+ worker_registry.start_heartbeat()+server: uvicorn.Server | None = None+ signum_to_signal_name = {+ signal.SIGINT: "signal.SIGINT",+ signal.SIGTERM: "signal.SIGTERM",+ }def handle_signal(signum: int, frame: object) -> None:"""Handle shutdown signals."""- logger.info(f"Received signal {signum}, initiating shutdown...")+ logger.info(f"Received signal {signum}({signum_to_signal_name[signum]}), initiating shutdown...")global_kill_flag.value = Trueif server:server.should_exit = True- # Setup signal handlers- signal.signal(signal.SIGTERM, handle_signal)- signal.signal(signal.SIGINT, handle_signal)+ for sigint, signal_name in signum_to_signal_name.items():+ logger.trace(f"Registering shutdown signal {sigint}: ({signum_to_signal_name[sigint]})")+ signal.signal(sigint, handle_signal)try:- # Clean up any existing process on the port- kill_process_on_port(port=PORT)+ kill_process_on_port(port=port)- # Create FastAPI app- app = create_fastapi_app(global_kill_flag=global_kill_flag,- heartbeat_timestamp=heartbeat_timestamp,- subprocess_registry=subprocess_registry)+ app = create_fastapi_app(+ global_kill_flag=global_kill_flag,+ worker_registry=worker_registry,+ port=port,+ )- # Configure and create Uvicorn serverconfig = uvicorn.Config(app=app,host=HOSTNAME,- port=PORT,+ port=port,log_level="warning",- reload=False-+ reload=False,)server = uvicorn.Server(config)- logger.info(f"Starting server on {HOSTNAME}:{PORT}")-- # Run server (blocks until shutdown)+ logger.info(f"Starting server on {HOSTNAME}:{port}")await server.serve()except KeyboardInterrupt:@@ -63,22 +83,13 @@ async def main() -> None:logger.error(f"Fatal error: {e}")raisefinally:- # Ensure kill flag is set and server is stoppedglobal_kill_flag.value = Trueif server:server.should_exit = True- await await_1s() # Give it time to shut down gracefully+ await await_1s()- for process in subprocess_registry:- if process.is_alive():- logger.info(f"Terminating subprocess {process.name} (PID: {process.pid})")- process.terminate()- process.join(timeout=2)- if process.is_alive():- logger.warning(f"Force killing subprocess {process.name} (PID: {process.pid})")- process.kill()- process.join()- logger.success("Done! Thank you for using SkellyCam 💀📸✨")+ worker_registry.shutdown_all()+ logger.success("Done! Thank you for using FreeMoCap 💀✨")if __name__ == "__main__":@@ -86,6 +97,6 @@ if __name__ == "__main__":asyncio.run(main())except Exception as e:logger.exception(f"Unhandled exception: {e}")- sys.exit(1)- else:- sys.exit(0)+ os._exit(1)+ print("Done!")+ os._exit(0)\ No newline at end of filediff --git a/freemocap/api/http/app/debug.py b/freemocap/api/http/app/debug.pynew file mode 100644index 00000000..f67082ef--- /dev/null+++ b/freemocap/api/http/app/debug.py@@ -0,0 +1,467 @@+"""+Debug endpoint: serves an HTML page that displays raw settings JSON+from both the HTTP GET /settings endpoint and the WebSocket settings/state+push, side by side, for visual confirmation of backend/frontend sync.++Access at: /debug/settings-sync+"""+import logging++from fastapi import APIRouter+from fastapi.responses import HTMLResponse++logger = logging.getLogger(__name__)++debug_router = APIRouter(prefix="/debug", tags=["Debug"])++_DEBUG_PAGE_HTML = r"""<!DOCTYPE html>+<html lang="en">+<head>+ <meta charset="UTF-8" />+ <meta name="viewport" content="width=device-width, initial-scale=1.0" />+ <title>FreeMoCap Settings Sync Debug</title>+ <style>+ @import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;600;700&family=DM+Sans:wght@400;500;700&display=swap');++ * { margin: 0; padding: 0; box-sizing: border-box; }++ :root {+ --bg: #0d1117;+ --surface: #161b22;+ --border: #30363d;+ --text: #c9d1d9;+ --text-dim: #8b949e;+ --green: #3fb950;+ --red: #f85149;+ --yellow: #d29922;+ --blue: #58a6ff;+ --orange: #d18616;+ --mono: 'JetBrains Mono', monospace;+ --sans: 'DM Sans', sans-serif;+ }++ body {+ background: var(--bg);+ color: var(--text);+ font-family: var(--sans);+ padding: 24px;+ min-height: 100vh;+ }++ header {+ display: flex;+ align-items: center;+ justify-content: space-between;+ margin-bottom: 20px;+ padding-bottom: 16px;+ border-bottom: 1px solid var(--border);+ }++ h1 {+ font-family: var(--mono);+ font-size: 18px;+ font-weight: 700;+ color: #f0f6fc;+ letter-spacing: -0.5px;+ }++ h1 span { color: var(--blue); }++ .controls {+ display: flex;+ gap: 12px;+ align-items: center;+ }++ label {+ font-family: var(--mono);+ font-size: 12px;+ color: var(--text-dim);+ }++ input[type="number"] {+ background: var(--surface);+ border: 1px solid var(--border);+ color: var(--text);+ font-family: var(--mono);+ font-size: 13px;+ padding: 6px 10px;+ border-radius: 6px;+ width: 80px;+ }++ button {+ background: var(--surface);+ border: 1px solid var(--border);+ color: var(--text);+ font-family: var(--mono);+ font-size: 12px;+ padding: 6px 14px;+ border-radius: 6px;+ cursor: pointer;+ transition: border-color 0.15s;+ }++ button:hover { border-color: var(--blue); color: var(--blue); }++ .status-bar {+ display: flex;+ gap: 24px;+ margin-bottom: 16px;+ font-family: var(--mono);+ font-size: 12px;+ }++ .status-item {+ display: flex;+ align-items: center;+ gap: 6px;+ }++ .dot {+ width: 8px;+ height: 8px;+ border-radius: 50%;+ background: var(--text-dim);+ }++ .dot.connected { background: var(--green); box-shadow: 0 0 6px var(--green); }+ .dot.error { background: var(--red); box-shadow: 0 0 6px var(--red); }++ .sync-verdict {+ margin-left: auto;+ padding: 4px 12px;+ border-radius: 4px;+ font-weight: 600;+ font-size: 13px;+ }++ .sync-verdict.synced { background: rgba(63,185,80,0.15); color: var(--green); }+ .sync-verdict.desynced { background: rgba(248,81,73,0.15); color: var(--red); }+ .sync-verdict.pending { background: rgba(210,153,34,0.15); color: var(--yellow); }++ .panels {+ display: grid;+ grid-template-columns: 1fr 1fr;+ gap: 16px;+ }++ .panel {+ background: var(--surface);+ border: 1px solid var(--border);+ border-radius: 8px;+ display: flex;+ flex-direction: column;+ overflow: hidden;+ }++ .panel-header {+ padding: 10px 16px;+ border-bottom: 1px solid var(--border);+ display: flex;+ align-items: center;+ justify-content: space-between;+ font-family: var(--mono);+ font-size: 13px;+ font-weight: 600;+ }++ .panel-header .source { color: var(--blue); }+ .panel-header .meta { color: var(--text-dim); font-weight: 400; font-size: 11px; }++ .panel-body {+ padding: 12px 16px;+ overflow: auto;+ max-height: calc(100vh - 200px);+ }++ pre {+ font-family: var(--mono);+ font-size: 12px;+ line-height: 1.6;+ white-space: pre-wrap;+ word-break: break-word;+ color: var(--text);+ }++ pre .key { color: var(--blue); }+ pre .string { color: #a5d6ff; }+ pre .number { color: #79c0ff; }+ pre .boolean { color: var(--orange); }+ pre .null { color: var(--text-dim); }++ .empty-state {+ color: var(--text-dim);+ font-family: var(--mono);+ font-size: 13px;+ padding: 40px 0;+ text-align: center;+ }++ .diff-summary {+ margin-top: 16px;+ background: var(--surface);+ border: 1px solid var(--border);+ border-radius: 8px;+ padding: 12px 16px;+ }++ .diff-summary h3 {+ font-family: var(--mono);+ font-size: 13px;+ font-weight: 600;+ margin-bottom: 8px;+ color: var(--text-dim);+ }++ .diff-entry {+ font-family: var(--mono);+ font-size: 12px;+ padding: 4px 0;+ border-bottom: 1px solid var(--border);+ }++ .diff-entry:last-child { border-bottom: none; }+ .diff-path { color: var(--yellow); }+ .diff-val-http { color: var(--red); }+ .diff-val-ws { color: var(--green); }+ </style>+</head>+<body>++<header>+ <h1>💀 FreeMoCap <span>Settings Sync Debug</span></h1>+ <div class="controls">+ <label>Poll (ms)+ <input type="number" id="poll-interval" value="2000" />+ </label>+ <button id="btn-connect">Connect</button>+ <button id="btn-disconnect" style="display:none;">Disconnect</button>+ <button id="btn-fetch-once">Fetch HTTP Once</button>+ </div>+</header>++<div class="status-bar">+ <div class="status-item">+ <div class="dot" id="dot-ws"></div>+ <span>WebSocket: <span id="ws-status">disconnected</span></span>+ </div>+ <div class="status-item">+ <div class="dot" id="dot-http"></div>+ <span>HTTP: <span id="http-status">idle</span></span>+ </div>+ <div class="status-item">+ <div class="dot" id="dot-http-version"></div>+ <span>HTTP v<span id="http-version">—</span></span>+ </div>+ <div class="status-item">+ <div class="dot" id="dot-ws-version"></div>+ <span>WS v<span id="ws-version">—</span></span>+ </div>+ <div class="sync-verdict pending" id="sync-verdict">waiting for data</div>+</div>++<div class="panels">+ <div class="panel">+ <div class="panel-header">+ <span><span class="source">GET /settings</span> — Backend (HTTP)</span>+ <span class="meta" id="http-timestamp">—</span>+ </div>+ <div class="panel-body">+ <pre id="http-json"><div class="empty-state">Click "Connect" or "Fetch HTTP Once"</div></pre>+ </div>+ </div>+ <div class="panel">+ <div class="panel-header">+ <span><span class="source">ws://…/websocket/connect</span> — Frontend (WebSocket)</span>+ <span class="meta" id="ws-timestamp">—</span>+ </div>+ <div class="panel-body">+ <pre id="ws-json"><div class="empty-state">Click "Connect" to open WebSocket</div></pre>+ </div>+ </div>+</div>++<div class="diff-summary" id="diff-section" style="display:none;">+ <h3>⚠ Differences (HTTP settings ↔ WebSocket settings)</h3>+ <div id="diff-entries"></div>+</div>++<script>+ let ws = null;+ let pollTimer = null;+ let httpData = null;+ let wsData = null;++ const $ = (id) => document.getElementById(id);++ // Derive HTTP and WS base URLs from the page's own origin,+ // since this page is served by the same FastAPI app.+ const HTTP_BASE = window.location.origin;+ const WS_BASE = HTTP_BASE.replace(/^http/, 'ws');++ function highlightJson(obj) {+ const raw = JSON.stringify(obj, null, 2);+ return raw+ .replace(/("(?:[^"\\\\]|\\\\.)*")\s*:/g, (_, key) => `<span class="key">${key}</span>:`)+ .replace(/:\s*("(?:[^"\\\\]|\\\\.)*")/g, (m, v) => m.replace(v, `<span class="string">${v}</span>`))+ .replace(/:\s*(\d+\.?\d*)/g, (m, v) => m.replace(v, `<span class="number">${v}</span>`))+ .replace(/:\s*(true|false)/g, (m, v) => m.replace(v, `<span class="boolean">${v}</span>`))+ .replace(/:\s*(null)/g, (m, v) => m.replace(v, `<span class="null">${v}</span>`));+ }++ function deepDiff(a, b, path) {+ path = path || '';+ const diffs = [];+ if (a === b) return diffs;+ if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') {+ diffs.push({ path: path || '(root)', httpVal: a, wsVal: b });+ return diffs;+ }+ const allKeys = new Set([...Object.keys(a), ...Object.keys(b)]);+ for (const key of allKeys) {+ const sub = path ? path + '.' + key : key;+ if (!(key in a)) {+ diffs.push({ path: sub, httpVal: undefined, wsVal: b[key] });+ } else if (!(key in b)) {+ diffs.push({ path: sub, httpVal: a[key], wsVal: undefined });+ } else {+ diffs.push(...deepDiff(a[key], b[key], sub));+ }+ }+ return diffs;+ }++ function truncVal(v) {+ const s = JSON.stringify(v);+ return s && s.length > 80 ? s.substring(0, 77) + '...' : s;+ }++ function updateSyncVerdict() {+ if (!httpData || !wsData) {+ $('sync-verdict').className = 'sync-verdict pending';+ $('sync-verdict').textContent = 'waiting for data';+ $('diff-section').style.display = 'none';+ return;+ }++ const diffs = deepDiff(httpData.settings, wsData.settings);++ if (diffs.length === 0) {+ $('sync-verdict').className = 'sync-verdict synced';+ const vDiff = (httpData.version || 0) - (wsData.version || 0);+ $('sync-verdict').textContent = '\u2713 IN SYNC' + (vDiff !== 0 ? ' (version diff: ' + vDiff + ')' : '');+ $('diff-section').style.display = 'none';+ } else {+ $('sync-verdict').className = 'sync-verdict desynced';+ $('sync-verdict').textContent = '\u2717 ' + diffs.length + ' DIFFERENCE' + (diffs.length > 1 ? 'S' : '') + ' DETECTED';+ $('diff-section').style.display = 'block';+ $('diff-entries').innerHTML = diffs.map(function(d) {+ return '<div class="diff-entry">' ++ '<span class="diff-path">' + d.path + '</span>: ' ++ '<span class="diff-val-http">HTTP=' + truncVal(d.httpVal) + '</span> \u2194 ' ++ '<span class="diff-val-ws">WS=' + truncVal(d.wsVal) + '</span>' ++ '</div>';+ }).join('');+ }+ }++ async function fetchHttp() {+ $('http-status').textContent = 'fetching\u2026';+ $('dot-http').className = 'dot';+ try {+ const resp = await fetch(HTTP_BASE + '/settings');+ if (!resp.ok) throw new Error('HTTP ' + resp.status + ': ' + resp.statusText);+ httpData = await resp.json();+ $('http-json').innerHTML = highlightJson(httpData);+ $('http-timestamp').textContent = new Date().toLocaleTimeString();+ $('http-version').textContent = httpData.version != null ? httpData.version : '\u2014';+ $('http-status').textContent = 'ok';+ $('dot-http').className = 'dot connected';+ updateSyncVerdict();+ } catch (err) {+ $('http-status').textContent = 'error: ' + err.message;+ $('dot-http').className = 'dot error';+ }+ }++ function connectWs() {+ const url = WS_BASE + '/websocket/connect';+ ws = new WebSocket(url);++ ws.onopen = function() {+ $('ws-status').textContent = 'connected';+ $('dot-ws').className = 'dot connected';+ };++ ws.onmessage = function(event) {+ if (typeof event.data !== 'string') return;+ try {+ var data = JSON.parse(event.data);+ if (data.message_type === 'settings/state') {+ wsData = data;+ $('ws-json').innerHTML = highlightJson(data);+ $('ws-timestamp').textContent = new Date().toLocaleTimeString();+ $('ws-version').textContent = data.version != null ? data.version : '\u2014';+ updateSyncVerdict();+ }+ } catch (e) {+ // Non-JSON or non-settings message — ignore+ }+ };++ ws.onclose = function(event) {+ $('ws-status').textContent = 'closed (code ' + event.code + ')';+ $('dot-ws').className = 'dot';+ ws = null;+ };++ ws.onerror = function() {+ $('ws-status').textContent = 'error';+ $('dot-ws').className = 'dot error';+ };+ }++ function disconnectAll() {+ if (ws) { ws.close(); ws = null; }+ if (pollTimer) { clearInterval(pollTimer); pollTimer = null; }+ $('btn-connect').style.display = '';+ $('btn-disconnect').style.display = 'none';+ $('ws-status').textContent = 'disconnected';+ $('dot-ws').className = 'dot';+ $('http-status').textContent = 'idle';+ $('dot-http').className = 'dot';+ }++ $('btn-connect').addEventListener('click', function() {+ connectWs();+ fetchHttp();+ var interval = parseInt($('poll-interval').value, 10) || 2000;+ pollTimer = setInterval(fetchHttp, interval);+ $('btn-connect').style.display = 'none';+ $('btn-disconnect').style.display = '';+ });++ $('btn-disconnect').addEventListener('click', disconnectAll);+ $('btn-fetch-once').addEventListener('click', fetchHttp);+</script>++</body>+</html>"""+++@debug_router.get(+ "/settings-sync",+ summary="Settings Sync Debug Page",+ tags=["Debug"],+ response_class=HTMLResponse,+)+def settings_sync_debug_page() -> HTMLResponse:+ """+ Serve the settings sync debug page.++ Displays raw JSON from both GET /settings (HTTP) and the+ WebSocket settings/state push side-by-side, with a live diff+ showing any discrepancies between the two.+ """+ return HTMLResponse(content=_DEBUG_PAGE_HTML)diff --git a/freemocap/api/http/app/settings.py b/freemocap/api/http/app/settings.pynew file mode 100644index 00000000..b640056f--- /dev/null+++ b/freemocap/api/http/app/settings.py@@ -0,0 +1,274 @@+"""+Unified application settings: the single serializable state blob+shared between frontend and backend over WebSocket.++Frontend can patch `config` sub-objects via `settings/patch` messages.+Runtime status fields are read-only from the frontend's perspective —+they are set by commands and hardware state changes on the backend.+"""+import asyncio+import logging+from enum import Enum++from pydantic import BaseModel, Field+from skellycam.core.camera.config.camera_config import CameraConfig, CameraConfigs+from skellycam.core.types.type_overloads import CameraIdString++from freemocap.core.pipeline.pipeline_configs import (+ CalibrationPipelineConfig,+ MocapPipelineConfig,+ RealtimePipelineConfig,+)++logger = logging.getLogger(__name__)+++# ---------------------------------------------------------------------------+# Sub-models: compose existing configs with runtime status+# ---------------------------------------------------------------------------+++class CameraStatus(str, Enum):+ DISCONNECTED = "disconnected"+ CONNECTED = "connected"+ ERROR = "error"+++class CameraState(BaseModel):+ """Per-camera config + runtime status."""+ config: CameraConfig+ status: CameraStatus = CameraStatus.DISCONNECTED+++class PipelineSettings(BaseModel):+ """Realtime pipeline config + runtime status."""+ config: RealtimePipelineConfig | None = None+ is_connected: bool = False+ pipeline_id: str | None = None+ camera_group_id: str | None = None+ is_paused: bool = False+++class CalibrationSettings(BaseModel):+ """Calibration config + runtime status."""+ config: CalibrationPipelineConfig = Field(default_factory=CalibrationPipelineConfig)+ is_recording: bool = False+ recording_progress: float = 0.0+ last_recording_path: str | None = None+ has_calibration_toml: bool = False+++class MocapSettings(BaseModel):+ """Motion capture config + runtime status."""+ config: MocapPipelineConfig = Field(default_factory=MocapPipelineConfig.default_realtime)+ is_recording: bool = False+ recording_progress: float = 0.0+ last_recording_path: str | None = None+++class VMCSettings(BaseModel):+ """VMC (Virtual Motion Capture) protocol output settings."""+ enabled: bool = False+ host: str = "127.0.0.1"+ port: int = 39539+++# ---------------------------------------------------------------------------+# Top-level settings blob+# ---------------------------------------------------------------------------+++class FreeMoCapSettings(BaseModel):+ """+ The authoritative, serializable application state.++ Sent in full over WebSocket as a `settings/state` message+ whenever any setting or runtime status changes.+ """+ cameras: dict[CameraIdString, CameraState] = Field(default_factory=dict)+ pipeline: PipelineSettings = Field(default_factory=PipelineSettings)+ calibration: CalibrationSettings = Field(default_factory=CalibrationSettings)+ mocap: MocapSettings = Field(default_factory=MocapSettings)+ vmc: VMCSettings = Field(default_factory=VMCSettings)+++# ---------------------------------------------------------------------------+# Settings Manager: owns the state, handles patches, notifies on change+# ---------------------------------------------------------------------------+++def _deep_merge(base: dict, patch: dict) -> dict:+ """+ RFC 7396 JSON Merge Patch: recursively merge patch into base.+ Keys in patch overwrite base. Nested dicts merge recursively.+ """+ result = base.copy()+ for key, value in patch.items():+ if isinstance(value, dict) and isinstance(result.get(key), dict):+ result[key] = _deep_merge(result[key], value)+ else:+ result[key] = value+ return result+++class SettingsManager:+ """+ Owns the authoritative FreeMoCapSettings instance.++ - Assembles current state from FreemocapApplication on demand.+ - Accepts patches from the frontend, validates, and applies them.+ - Provides an asyncio.Event for WebSocket tasks to await state changes.+ - Maintains a monotonic version counter for ordering.+ """++ def __init__(self) -> None:+ self._settings = FreeMoCapSettings()+ self._version: int = 0+ self._changed = asyncio.Event()++ @property+ def version(self) -> int:+ return self._version++ @property+ def settings(self) -> FreeMoCapSettings:+ return self._settings++ def get_state_message(self) -> dict:+ """Build a `settings/state` WebSocket message."""+ return {+ "message_type": "settings/state",+ "settings": self._settings.model_dump(),+ "version": self._version,+ }++ def notify_changed(self) -> None:+ """Bump version and wake any waiters."""+ self._version += 1+ self._changed.set()++ async def wait_for_change(self) -> None:+ """Block until notify_changed() is called. Clears the event after waking."""+ await self._changed.wait()+ self._changed.clear()++ def apply_patch(self, patch: dict) -> FreeMoCapSettings:+ """+ Apply a partial update (JSON merge-patch) to the current settings.++ Validates the result via Pydantic. If validation fails,+ the settings are left unchanged and the error is raised.+ """+ current = self._settings.model_dump()+ merged = _deep_merge(base=current, patch=patch)+ # Pydantic validates on construction — if this raises, settings are unchanged+ new_settings = FreeMoCapSettings.model_validate(merged)+ self._settings = new_settings+ self.notify_changed()+ logger.info(f"Settings patched (v{self._version}): {list(patch.keys())}")+ return self._settings++ def update_from_app(self, app: "FreemocapApplication") -> None:+ """+ Rebuild settings from the current application state.++ All config values are read from the live application objects+ (pipeline, camera groups) so the settings blob is always+ the single source of truth. Runtime status fields (is_recording,+ recording_progress, etc.) are preserved from the internal state+ since they are only tracked here, not on the pipeline.+ """+ # Camera state — read from live camera groups+ cameras: dict[CameraIdString, CameraState] = {}+ for camera_group in app.camera_group_manager.camera_groups.values():+ for cam_id, cam_config in camera_group.configs.items():+ cameras[cam_id] = CameraState(+ config=cam_config,+ status=CameraStatus.CONNECTED,+ )++ # Pipeline state — read from live pipeline+ pipeline = PipelineSettings()+ realtime_pipelines = app.realtime_pipeline_manager.pipelines+ first_pipeline = None+ if realtime_pipelines:+ first_pipeline = next(iter(realtime_pipelines.values()))+ pipeline = PipelineSettings(+ config=first_pipeline.config,+ is_connected=first_pipeline.alive,+ pipeline_id=first_pipeline.id,+ camera_group_id=first_pipeline.camera_group.id,+ )++ # Calibration — read config from the live pipeline when available,+ # fall back to internal state when no pipeline exists.+ # Runtime status fields are always from internal state.+ calibration_config = (+ first_pipeline.config.calibration_config+ if first_pipeline is not None+ else self._settings.calibration.config+ )+ calibration = CalibrationSettings(+ config=calibration_config,+ is_recording=self._settings.calibration.is_recording,+ recording_progress=self._settings.calibration.recording_progress,+ last_recording_path=self._settings.calibration.last_recording_path,+ has_calibration_toml=self._settings.calibration.has_calibration_toml,+ )++ # Mocap — same pattern: read config from live pipeline when available.+ mocap_config = (+ first_pipeline.config.mocap_config+ if first_pipeline is not None+ else self._settings.mocap.config+ )+ mocap = MocapSettings(+ config=mocap_config,+ is_recording=self._settings.mocap.is_recording,+ recording_progress=self._settings.mocap.recording_progress,+ last_recording_path=self._settings.mocap.last_recording_path,+ )++ self._settings = FreeMoCapSettings(+ cameras=cameras,+ pipeline=pipeline,+ calibration=calibration,+ mocap=mocap,+ vmc=self._settings.vmc,+ )+ self.notify_changed()++ def update_calibration_status(+ self,+ is_recording: bool | None = None,+ recording_progress: float | None = None,+ last_recording_path: str | None = None,+ has_calibration_toml: bool | None = None,+ ) -> None:+ """Update calibration runtime status fields and notify."""+ cal = self._settings.calibration+ if is_recording is not None:+ cal.is_recording = is_recording+ if recording_progress is not None:+ cal.recording_progress = recording_progress+ if last_recording_path is not None:+ cal.last_recording_path = last_recording_path+ if has_calibration_toml is not None:+ cal.has_calibration_toml = has_calibration_toml+ self.notify_changed()++ def update_mocap_status(+ self,+ is_recording: bool | None = None,+ recording_progress: float | None = None,+ last_recording_path: str | None = None,+ ) -> None:+ """Update mocap runtime status fields and notify."""+ moc = self._settings.mocap+ if is_recording is not None:+ moc.is_recording = is_recording+ if recording_progress is not None:+ moc.recording_progress = recording_progress+ if last_recording_path is not None:+ moc.last_recording_path = last_recording_path+ self.notify_changed()\ No newline at end of filediff --git a/freemocap/api/http/app/state.py b/freemocap/api/http/app/state.pyindex d62df2ca..4a582a60 100644--- a/freemocap/api/http/app/state.py+++ b/freemocap/api/http/app/state.py@@ -1,17 +1,26 @@+"""+HTTP endpoint serving the current FreeMoCapSettings from SettingsManager.++Useful for initial hydration before the WebSocket connects, and+as a polling fallback for clients that don't use WebSocket.+"""import loggingfrom fastapi import APIRouter-from skellycam.skellycam_app.skellycam_app import get_skellycam_app++from freemocap.app.freemocap_application import get_freemocap_applogger = logging.getLogger(__name__)state_router = APIRouter()-@state_router.get("/state", summary="Application State", tags=['App'])-def app_state_endpoint():+@state_router.get("/settings", summary="Current Settings State", tags=["App"])+def settings_state_endpoint() -> dict:"""- A simple endpoint that serves the current state of the application+ Serve the current settings blob (same payload shape as+ the `settings/state` WebSocket message)."""- logger.api("Serving application state from `app/state` endpoint...")-- return get_skellycam_app().state_dto()+ logger.api("Serving settings state from `/settings` endpoint...")+ app = get_freemocap_app()+ app.settings_manager.update_from_app(app)+ return app.settings_manager.get_state_message()diff --git a/freemocap/api/http/calibration/calibration_router.py b/freemocap/api/http/calibration/calibration_router.pyindex 37d2b5d4..050af788 100644--- a/freemocap/api/http/calibration/calibration_router.py+++ b/freemocap/api/http/calibration/calibration_router.py@@ -1,14 +1,13 @@import logging+from copy import deepcopyfrom pathlib import Pathfrom fastapi import APIRouter, HTTPException-from pydantic import BaseModel-from pydantic import Field+from pydantic import BaseModel, Fieldfrom skellycam.core.recorders.videos.recording_info import RecordingInfofrom freemocap.app.freemocap_application import get_freemocap_app-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.posthoc_calibration_pipeline import \- CalibrationpipelineConfig+from freemocap.core.pipeline.pipeline_configs import CalibrationPipelineConfiglogger = logging.getLogger(__name__)@@ -19,7 +18,7 @@ calibration_router = APIRouter(prefix="/calibration", tags=["Calibration"])class CalibrationConfigRequest(BaseModel):- config: CalibrationpipelineConfig+ config: CalibrationPipelineConfigclass CalibrationConfigResponse(BaseModel):@@ -29,34 +28,34 @@ class CalibrationConfigResponse(BaseModel):class StartCalibrationRecordingRequest(BaseModel):calibration_recording_directory: str = Field(alias="calibrationRecordingDirectory")- calibration_pipeline_config: CalibrationpipelineConfig = Field(alias="calibrationTaskConfig")+ calibration_config: CalibrationPipelineConfig = Field(alias="calibrationTaskConfig")def to_recording_info(self) -> RecordingInfo:- recordings_directory = Path(self.calibration_recording_directory).parent- recording_name = Path(self.calibration_recording_directory).stem- if not recording_name.endswith('_calibration'):- recording_name += '_calibration'+ recording_dir = Path(self.calibration_recording_directory).expanduser()+ recording_name = recording_dir.stem+ if not recording_name.endswith("_calibration"):+ recording_name += "_calibration"return RecordingInfo(- recording_directory=str(Path(self.calibration_recording_directory).parent).replace('~', str(Path.home())),+ recording_directory=str(recording_dir.parent),recording_name=recording_name,- mic_device_index=-1+ mic_device_index=-1,)class StopCalibrationRecordingRequest(BaseModel):- calibration_pipeline_config: CalibrationpipelineConfig = Field(alias="calibrationTaskConfig")+ calibration_config: CalibrationPipelineConfig = Field(alias="calibrationTaskConfig")class CalibrateRecordingRequest(BaseModel):calibration_recording_directory: str = Field(alias="calibrationRecordingDirectory")- calibration_pipeline_config: CalibrationpipelineConfig = Field(alias="calibrationTaskConfig")+ calibration_config: CalibrationPipelineConfig = Field(alias="calibrationTaskConfig")def to_recording_info(self) -> RecordingInfo:-+ recording_dir = Path(self.calibration_recording_directory).expanduser()return RecordingInfo(- recording_directory=str(Path(self.calibration_recording_directory).parent).replace('~', str(Path.home())),- recording_name=Path(self.calibration_recording_directory).stem,- mic_device_index=-1+ recording_directory=str(recording_dir.parent),+ recording_name=recording_dir.stem,+ mic_device_index=-1,)@@ -73,11 +72,25 @@ class CalibrateRecordingResponse(BaseModel):# ==================== Endpoints ====================+@calibration_router.post("/config/update/all")def update_all_calibration_config(request: CalibrationConfigRequest) -> CalibrationConfigResponse:- """Update calibration configuration."""+ """Update calibration configuration on all active realtime pipelines via SettingsManager."""try:- get_freemocap_app().realtime_pipeline_manager.update_calibration_task_config(request.config)+ app = get_freemocap_app()++ # Update settings manager (source of truth), which notifies WebSocket clients+ app.settings_manager.apply_patch({+ "calibration": {"config": request.config.model_dump()},+ })++ # Sync to running pipelines+ with app.realtime_pipeline_manager.lock:+ for pipeline in app.realtime_pipeline_manager.pipelines.values():+ new_config = deepcopy(pipeline.config)+ new_config.calibration_config = request.config+ pipeline.update_config(new_config=new_config)+return CalibrationConfigResponse(success=True, message="Configuration updated")except Exception as e:logger.exception(f"Error updating calibration config: {e}")@@ -85,50 +98,57 @@ def update_all_calibration_config(request: CalibrationConfigRequest) -> Calibrat@calibration_router.post("/recording/start")-async def start_calibration_recording(request: StartCalibrationRecordingRequest) -> StartCalibrationRecordingResponse:+async def start_calibration_recording(+ request: StartCalibrationRecordingRequest,+) -> StartCalibrationRecordingResponse:"""Start calibration recording with given config."""try:recording_info = request.to_recording_info()- if not recording_info.recording_name.endswith('_calibration'):- recording_info.recording_name += '_calibration'-- await get_freemocap_app().start_recording_all(recording_info=recording_info, )- logger.info(f"Starting recording : {recording_info}")+ await get_freemocap_app().start_recording_all(recording_info=recording_info)+ logger.info(f"Starting calibration recording: {recording_info}")return StartCalibrationRecordingResponse(success=True, message="Recording started")except Exception as e:- logger.exception(f"Error starting recording: {e}")+ logger.exception(f"Error starting calibration recording: {e}")raise HTTPException(status_code=500, detail=str(e))@calibration_router.post("/recording/stop")-async def stop_calibration_recording(request: StopCalibrationRecordingRequest) -> dict[str, bool]:- """Stop current calibration recording."""+async def stop_calibration_recording(+ request: StopCalibrationRecordingRequest,+) -> dict[str, bool]:+ """Stop current calibration recording and launch posthoc calibration pipeline."""app = get_freemocap_app()try:recording_info = await app.stop_recording_all()- await app.create_posthoc_calibration_pipeline(recording_info=recording_info,- calibration_pipeline_config=request.calibration_pipeline_config)- logger.info("Stopping recording")+ if recording_info is None:+ raise RuntimeError("No active recording to stop")+ await app.create_posthoc_calibration_pipeline(+ recording_info=recording_info,+ calibration_config=request.calibration_config,+ )+ logger.info("Calibration recording stopped, posthoc calibration pipeline launched")return {"success": True}except Exception as e:- logger.error(f"Error stopping recording: {e}")+ logger.exception(f"Error stopping calibration recording: {e}")raise HTTPException(status_code=500, detail=str(e))@calibration_router.post("/recording/calibrate")async def calibrate_recording(request: CalibrateRecordingRequest) -> CalibrateRecordingResponse:- """Process and calibrate a recorded session."""+ """Process and calibrate a previously recorded session."""app = get_freemocap_app()try:recording_info = request.to_recording_info()- await app.create_posthoc_calibration_pipeline(recording_info=recording_info,- calibration_pipeline_config=request.calibration_pipeline_config)+ await app.create_posthoc_calibration_pipeline(+ recording_info=recording_info,+ calibration_config=request.calibration_config,+ )logger.info(f"Calibrating recording at: {recording_info.full_recording_path}")return CalibrateRecordingResponse(success=True,- message="Calibration completed",- results={}+ message="Calibration pipeline launched",+ results={},)except Exception as e:- logger.error(f"Error calibrating recording: {e}")- raise HTTPException(status_code=500, detail=str(e))+ logger.exception(f"Error calibrating recording: {e}")+ raise HTTPException(status_code=500, detail=str(e))\ No newline at end of filediff --git a/freemocap/api/http/mocap/mocap_router.py b/freemocap/api/http/mocap/mocap_router.pyindex de53c56e..f153a9b7 100644--- a/freemocap/api/http/mocap/mocap_router.py+++ b/freemocap/api/http/mocap/mocap_router.py@@ -1,14 +1,13 @@import logging+from copy import deepcopyfrom pathlib import Pathfrom fastapi import APIRouter, HTTPException-from pydantic import BaseModel-from pydantic import Field+from pydantic import BaseModel, Fieldfrom skellycam.core.recorders.videos.recording_info import RecordingInfofrom freemocap.app.freemocap_application import get_freemocap_app-from freemocap.core.pipeline.posthoc_pipelines.posthoc_mocap_pipeline.posthoc_mocap_pipeline import \- MocapPipelineTaskConfig+from freemocap.core.pipeline.pipeline_configs import MocapPipelineConfiglogger = logging.getLogger(__name__)@@ -19,7 +18,7 @@ mocap_router = APIRouter(prefix="/mocap", tags=["Mocap"])class MocapConfigRequest(BaseModel):- config: MocapPipelineTaskConfig+ config: MocapPipelineConfigclass MocapConfigResponse(BaseModel):@@ -29,34 +28,34 @@ class MocapConfigResponse(BaseModel):class StartMocapRecordingRequest(BaseModel):mocap_recording_directory: str = Field(alias="mocapRecordingDirectory")- mocap_task_config: MocapPipelineTaskConfig = Field(alias="mocapTaskConfig")+ mocap_config: MocapPipelineConfig = Field(alias="mocapTaskConfig")def to_recording_info(self) -> RecordingInfo:- recordings_directory = Path(self.mocap_recording_directory).expanduser().parent- recording_name = Path(self.mocap_recording_directory).stem- if not recording_name.endswith('_mocap'):- recording_name += '_mocap'+ recording_dir = Path(self.mocap_recording_directory).expanduser()+ recording_name = recording_dir.stem+ if not recording_name.endswith("_mocap"):+ recording_name += "_mocap"return RecordingInfo(- recording_directory=str(recordings_directory),+ recording_directory=str(recording_dir.parent),recording_name=recording_name,- mic_device_index=-1+ mic_device_index=-1,)-class StopMocapRecordingRequest(BaseModel):- mocap_task_config: MocapPipelineTaskConfig = Field(alias="mocapTaskConfig")+ mocap_config: MocapPipelineConfig = Field(alias="mocapTaskConfig")class ProcessMocapRecordingRequest(BaseModel):mocap_recording_directory: str = Field(alias="mocapRecordingDirectory")- mocap_task_config: MocapPipelineTaskConfig = Field(alias="mocapTaskConfig")+ mocap_config: MocapPipelineConfig = Field(alias="mocapTaskConfig")def to_recording_info(self) -> RecordingInfo:+ recording_dir = Path(self.mocap_recording_directory).expanduser()return RecordingInfo(- recording_directory=str(Path(self.mocap_recording_directory).parent),- recording_name=Path(self.mocap_recording_directory).stem,- mic_device_index=-1+ recording_directory=str(recording_dir.parent),+ recording_name=recording_dir.stem,+ mic_device_index=-1,)@@ -73,63 +72,81 @@ class MocapRecordingResponse(BaseModel):# ==================== Endpoints ====================+@mocap_router.post("/config/update/all")def update_all_mocap_config(request: MocapConfigRequest) -> MocapConfigResponse:- """Update mocap configuration."""+ """Update mocap configuration on all active realtime pipelines via SettingsManager."""try:- get_freemocap_app().realtime_pipeline_manager.update_mocap_task_config(request.config)- return MocapConfigResponse(success=True, message="Mocap Configuration updated")+ app = get_freemocap_app()++ # Update settings manager (source of truth), which notifies WebSocket clients+ app.settings_manager.apply_patch({+ "mocap": {"config": request.config.model_dump()},+ })++ # Sync to running pipelines+ with app.realtime_pipeline_manager.lock:+ for pipeline in app.realtime_pipeline_manager.pipelines.values():+ new_config = deepcopy(pipeline.config)+ new_config.mocap_config = request.config+ pipeline.update_config(new_config=new_config)++ return MocapConfigResponse(success=True, message="Mocap configuration updated")except Exception as e:logger.exception(f"Error updating mocap config: {e}")raise HTTPException(status_code=500, detail=str(e))@mocap_router.post("/recording/start")-async def start_mocap_recording(request: StartMocapRecordingRequest) -> StartMocapRecordingResponse:+async def start_mocap_recording(+ request: StartMocapRecordingRequest,+) -> StartMocapRecordingResponse:"""Start mocap recording with given config."""try:recording_info = request.to_recording_info()- if not recording_info.recording_name.endswith('_mocap'):- recording_info.recording_name += '_mocap'-- # await get_freemocap_app().create_or_update_realtime_mocap_pipeline(request.mocap_task_config)- await get_freemocap_app().start_recording_all(recording_info=recording_info, )- logger.info(f"Starting mocap recording : {recording_info}")+ await get_freemocap_app().start_recording_all(recording_info=recording_info)+ logger.info(f"Starting mocap recording: {recording_info}")return StartMocapRecordingResponse(success=True, message="Mocap recording started")except Exception as e:- logger.exception(f"Error starting recording: {e}")+ logger.exception(f"Error starting mocap recording: {e}")raise HTTPException(status_code=500, detail=str(e))@mocap_router.post("/recording/stop")async def stop_mocap_recording(request: StopMocapRecordingRequest) -> dict[str, bool]:- """Stop current mocap recording."""+ """Stop current mocap recording and launch posthoc mocap pipeline."""app = get_freemocap_app()try:recording_info = await app.stop_recording_all()- await app.posthoc_pipeline_manager.create_posthoc_mocap_pipeline(recording_info=recording_info,- mocap_task_config=request.mocap_task_config)- logger.info("Stopping recording")+ if recording_info is None:+ raise RuntimeError("No active recording to stop")+ await app.create_posthoc_mocap_pipeline(+ recording_info=recording_info,+ mocap_config=request.mocap_config,+ )+ logger.info("Mocap recording stopped, posthoc mocap pipeline launched")return {"success": True}except Exception as e:- logger.error(f"Error stopping recording: {e}")+ logger.exception(f"Error stopping mocap recording: {e}")raise HTTPException(status_code=500, detail=str(e))@mocap_router.post("/recording/process")async def process_mocap_recording(request: ProcessMocapRecordingRequest) -> MocapRecordingResponse:- """Process and calibrate a recorded session."""+ """Process a previously recorded session with mocap pipeline."""app = get_freemocap_app()try:recording_info = request.to_recording_info()- await app.posthoc_pipeline_manager.create_posthoc_mocap_pipeline(recording_info=recording_info,- mocap_task_config=request.mocap_task_config)+ await app.create_posthoc_mocap_pipeline(+ recording_info=recording_info,+ mocap_config=request.mocap_config,+ )logger.info(f"Processing mocap recording at: {recording_info.full_recording_path}")return MocapRecordingResponse(success=True,- message="Mocap processing pipeline completed",- results={}+ message="Mocap processing pipeline launched",+ results={},)except Exception as e:- logger.error(f"Error calibrating recording: {e}")- raise HTTPException(status_code=500, detail=str(e))+ logger.exception(f"Error processing mocap recording: {e}")+ raise HTTPException(status_code=500, detail=str(e))\ No newline at end of filediff --git a/freemocap/api/http/pipelines/pipeline_router.py b/freemocap/api/http/pipelines/pipeline_router.pyindex 59ecde88..c77873eb 100644--- a/freemocap/api/http/pipelines/pipeline_router.py+++ b/freemocap/api/http/pipelines/pipeline_router.py@@ -14,13 +14,14 @@ from freemocap.system.default_paths import default_recording_name, get_default_rlogger = logging.getLogger(__name__)-pipeline_router = APIRouter(prefix=f"/pipeline",- tags=["Processing Pipelines"], )+pipeline_router = APIRouter(prefix="/pipeline", tags=["Processing Pipelines"])class PipelineConnectRequest(BaseModel):- camera_configs: CameraConfigs = Field(...,- description="List of camera IDs comprising the CameraGroup we're attaching a pipeline to")+ camera_configs: CameraConfigs = Field(+ ...,+ description="Camera configurations for the CameraGroup we're attaching a pipeline to",+ )pipeline_config: RealtimePipelineConfig | None = None@property@@ -31,12 +32,21 @@ class PipelineConnectRequest(BaseModel):class PipelineCreateResponse(BaseModel):- camera_group_id: CameraGroupIdString = Field(..., description="ID of the camera group attached to the pipeline")- pipeline_id: str = Field(..., description="ID of the processing pipeline to which the camera group is attached")- camera_configs: CameraConfigs = Field(..., description="Camera configurations for the cameras in the camera group")+ camera_group_id: CameraGroupIdString = Field(+ ...,+ description="ID of the camera group attached to the pipeline",+ )+ pipeline_id: str = Field(+ ...,+ description="ID of the processing pipeline",+ )+ camera_configs: CameraConfigs = Field(+ ...,+ description="Camera configurations for the cameras in the camera group",+ )@classmethod- def from_pipeline(cls, pipeline) -> "PipelineCreateResponse":+ def from_pipeline(cls, pipeline: "RealtimePipeline") -> "PipelineCreateResponse":return cls(camera_group_id=pipeline.camera_group.id,pipeline_id=pipeline.id,@@ -47,61 +57,72 @@ class PipelineCreateResponse(BaseModel):class StartRecordingRequest(BaseModel):recording_name: str = Field(default_factory=default_recording_name,- description="Name of the recording"+ description="Name of the recording",)recording_directory: str = Field(default_factory=get_default_recording_folder_path,- description="Path to save the recording"+ description="Path to save the recording",)mic_device_index: int = Field(default=-1,- description="Index of the microphone device"+ description="Index of the microphone device",)def recording_full_path(self) -> str:return str(Path(self.recording_directory) / self.recording_name)-@pipeline_router.post("/connect",- summary="Create a processing pipeline and attach it to a camera group"- )+@pipeline_router.post(+ "/connect",+ summary="Create a processing pipeline and attach it to a camera group",+)async def pipeline_connect_endpoint(- request: PipelineConnectRequest = Body(...,- description="Request body containing desired camera configuration",- examples=[- PipelineConnectRequest(camera_configs={- '0': CameraConfig(camera_id='0')})])) -> PipelineCreateResponse:+ request: PipelineConnectRequest = Body(+ ...,+ description="Request body containing desired camera configuration",+ examples=[+ PipelineConnectRequest(+ camera_configs={"0": CameraConfig(camera_id="0")},+ ),+ ],+ ),+) -> PipelineCreateResponse:logger.api(f"Received `pipeline/connect` POST request - \n {request.model_dump_json(indent=2)}")try:pipeline_config = request.pipeline_config or RealtimePipelineConfig.from_camera_configs(- camera_configs=request.camera_configs)- pipeline = await get_freemocap_app().create_or_update_realtime_pipeline(pipeline_config=pipeline_config)+ camera_configs=request.camera_configs,+ )+ pipeline = await get_freemocap_app().create_or_update_realtime_pipeline(+ pipeline_config=pipeline_config,+ )response = PipelineCreateResponse.from_pipeline(pipeline=pipeline)- logger.api(- f"`pipeline/connect` POST request handled successfully - \n {response.model_dump_json(indent=2)}")+ logger.api(f"`pipeline/connect` POST request handled successfully - \n {response.model_dump_json(indent=2)}")return responseexcept Exception as e:logger.error(f"Error when processing `pipeline/connect` request: {type(e).__name__} - {e}")logger.exception(e)- raise HTTPException(status_code=500,- detail=f"Error when processing `pipeline/connect` request: {type(e).__name__} - {e}")+ raise HTTPException(+ status_code=500,+ detail=f"Error when processing `pipeline/connect` request: {type(e).__name__} - {e}",+ )-@pipeline_router.delete("/all/close",- summary="Disconnect/shutdown all processing pipelines"- )-async def pipeline_close_endpoint():- logger.api(f"Received `pipeline/close` DELETE request")+@pipeline_router.delete(+ "/all/close",+ summary="Disconnect/shutdown all processing pipelines",+)+async def pipeline_close_endpoint() -> None:+ logger.api("Received `pipeline/close` DELETE request")try:-get_freemocap_app().close_pipelines()- logger.api(- f"`pipeline/disconnect` DELETE request handled successfully ")+ logger.api("`pipeline/close` DELETE request handled successfully")except Exception as e:- logger.error(f"Error when processing `pipeline/disconnect` request: {type(e).__name__} - {e}")+ logger.error(f"Error when processing `pipeline/close` request: {type(e).__name__} - {e}")logger.exception(e)- raise HTTPException(status_code=500,- detail=f"Error when processing `pipeline/disconnect` request: {type(e).__name__} - {e}")+ raise HTTPException(+ status_code=500,+ detail=f"Error when processing `pipeline/close` request: {type(e).__name__} - {e}",+ )@pipeline_router.get("/all/pause_unpause", summary="Pause/unpause cameras")@@ -115,19 +136,19 @@ def pause_camera_groups(request: Request) -> bool:@pipeline_router.post("/all/record/start", summary="Start recording")-def start_recording(- request: Request,- request_body: StartRecordingRequest = Body(..., examples=[StartRecordingRequest()])+async def start_recording(+ request: Request,+ request_body: StartRecordingRequest = Body(..., examples=[StartRecordingRequest()]),) -> bool:try:if request_body.recording_directory.startswith("~"):request_body.recording_directory = str(Path(request_body.recording_directory.replace("~", str(Path.home()), 1)))-Path(request_body.recording_directory).mkdir(parents=True, exist_ok=True)- get_freemocap_app().start_recording_all(RecordingInfo(**request_body.model_dump()))-+ await get_freemocap_app().start_recording_all(+ recording_info=RecordingInfo(**request_body.model_dump()),+ )return Trueexcept Exception as e:logger.error(f"Error in {request.url}: {type(e).__name__} - {e}", exc_info=True)@@ -135,10 +156,10 @@ def start_recording(@pipeline_router.get("/all/record/stop", summary="Stop recording")-def stop_recording(request: Request) -> bool:+async def stop_recording(request: Request) -> bool:try:- get_freemocap_app().stop_recording_all()+ await get_freemocap_app().stop_recording_all()return Trueexcept Exception as e:logger.error(f"Error in {request.url}: {type(e).__name__} - {e}", exc_info=True)- raise HTTPException(status_code=500, detail=str(e))+ raise HTTPException(status_code=500, detail=str(e))\ No newline at end of filediff --git a/freemocap/api/routers.py b/freemocap/api/routers.pyindex 5dcf98ff..4f7a251b 100644--- a/freemocap/api/routers.py+++ b/freemocap/api/routers.py@@ -1,9 +1,18 @@from skellycam.api.http.cameras.camera_router import camera_router+from freemocap.api.http.app.debug import debug_router+from freemocap.api.http.app.health import health_router+from freemocap.api.http.app.shutdown import shutdown_router+from freemocap.api.http.app.state import state_routerfrom freemocap.api.http.calibration.calibration_router import calibration_routerfrom freemocap.api.http.mocap.mocap_router import mocap_routerfrom freemocap.api.http.pipelines.pipeline_router import pipeline_router+APP_ROUTERS = [health_router,+ shutdown_router,+ state_router,+ debug_router]+SKELLYCAM_ROUTERS = [camera_router,]diff --git a/freemocap/api/server/server_constants.py b/freemocap/api/server/server_constants.pydeleted file mode 100644index a6d19787..00000000--- a/freemocap/api/server/server_constants.py+++ /dev/null@@ -1,4 +0,0 @@-PROTOCOL = "http"-HOSTNAME = "localhost"-PORT = 53117-APP_URL = f"{PROTOCOL}://{HOSTNAME}:{PORT}"diff --git a/freemocap/api/server/server_manager.py b/freemocap/api/server/server_manager.pydeleted file mode 100644index f89ff338..00000000--- a/freemocap/api/server/server_manager.py+++ /dev/null@@ -1,98 +0,0 @@-import logging-import multiprocessing-import threading-import time--import psutil-import uvicorn-from freemocap.app.freemocap_app_lifespan.freemocap_app_setup import create_freemocap_fastapi_app-from uvicorn import Server--from freemocap.api.server.server_constants import HOSTNAME, PORT-from freemocap.app.freemocap_application import get_freemocap_app-from freemocap.utilities.kill_process_on_port import kill_process_on_port--logger = logging.getLogger(__name__)---class UvicornServerManager:- def __init__(self,- global_kill_flag: multiprocessing.Value,- hostname: str = HOSTNAME,- port: int = PORT,- log_level: str = "info"):- self._global_kill_flag = global_kill_flag- get_freemocap_app()- self.hostname: str = hostname- self.port: int = port- self.server_thread: threading.Thread | None = None- self.server: Server | None = None- self.log_level: str = log_level- self.shutdown_listener_thread = threading.Thread(target=self.shutdown_listener_loop,- name="UvicornServerManagerShutdownListenerThread",- daemon=True)- self.shutdown_listener_thread.start()-- @property- def is_running(self):- return self.server_thread.is_alive() if self.server_thread else False-- def run_server(self):-- config = uvicorn.Config(- create_freemocap_fastapi_app,- host=self.hostname,- port=self.port,- log_level=0, # self.log_level,- reload=True,- factory=True- )-- logger.info(f"Starting uvicorn server on {self.hostname}:{self.port}")- kill_process_on_port(port=self.port)- self.server = uvicorn.Server(config)-- def server_thread():- logger.debug("Server thread started")- try:- logger.debug("Running uvicorn server...")- self.server.run() # blocks until server is stopped- logger.info("Running uvicorn server...")- except Exception as e:- logger.error(f"A fatal error occurred in the uvicorn server: {e}")- logger.exception(e)- raise- finally:- self._global_kill_flag.value = True- logger.info(f"Uvicorn server thread completed")-- self.server_thread = threading.Thread(target=server_thread, name="UvicornServerManagerThread", daemon=True)- self.server_thread.start()- while not self._global_kill_flag.value and self.server_thread.is_alive():- time.sleep(1)- logger.debug("Server thread shutdown")- # kill_process_on_port(port=self.port)-- def shutdown_server(self):- logger.info("Shutting down Uvicorn Server...")- self._global_kill_flag.value = True- if self.server:- self.server.should_exit = True- time.sleep(1)- try:- # Kill child processes- current_process = psutil.Process()- for child in current_process.children(recursive=True):- logger.warning(f"Killing child process: {child} - figure out how to make this shut down gracefully!")- child.kill()- except Exception as e:- logger.exception(f"Error killing child processes: {e}")-- def shutdown_listener_loop(self):- logger.info("Starting shutdown listener loop")- while self._global_kill_flag.value is False:- time.sleep(1)- if self._global_kill_flag.value:- logger.info("Detected global kill flag - shutting down server")- self.shutdown_server()- logger.info("Shutdown listener loop ended")diff --git a/freemocap/api/server/server_singleton.py b/freemocap/api/server/server_singleton.pydeleted file mode 100644index 63427a57..00000000--- a/freemocap/api/server/server_singleton.py+++ /dev/null@@ -1,21 +0,0 @@-import multiprocessing-from typing import Optional--from freemocap.api.server.server_manager import UvicornServerManager--UVICORN_SERVER_MANAGER: Optional[UvicornServerManager] = None---def create_server_manager(global_kill_flag: multiprocessing.Value, *args, **kwargs) -> UvicornServerManager:- global UVICORN_SERVER_MANAGER- if UVICORN_SERVER_MANAGER is not None:- raise Exception("Server manager already created, but you tried to create it again!")- UVICORN_SERVER_MANAGER = UvicornServerManager(global_kill_flag, *args, **kwargs)- return UVICORN_SERVER_MANAGER---def get_server_manager() -> UvicornServerManager:- global UVICORN_SERVER_MANAGER- if UVICORN_SERVER_MANAGER is None:- raise Exception("Server manager not created yet!")- return UVICORN_SERVER_MANAGERdiff --git a/freemocap/api/server_constants.py b/freemocap/api/server_constants.pyindex a6d19787..2cfa46fc 100644--- a/freemocap/api/server_constants.py+++ b/freemocap/api/server_constants.py@@ -1,4 +1,27 @@+import socket+PROTOCOL = "http"HOSTNAME = "localhost"-PORT = 53117-APP_URL = f"{PROTOCOL}://{HOSTNAME}:{PORT}"+PREFERRED_PORT = 53117+MAX_PORT_ATTEMPTS = 50+PORT_SENTINEL = "FREEMOCAP_PORT"+++def find_available_port(*, hostname: str = HOSTNAME, preferred_port: int = PREFERRED_PORT, max_attempts: int = MAX_PORT_ATTEMPTS) -> int:+ """Try to bind to the preferred port, incrementing upward until one is available."""+ for offset in range(max_attempts):+ port = preferred_port + offset+ try:+ with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:+ s.bind((hostname, port))+ return port+ except OSError:+ continue+ raise RuntimeError(+ f"Could not find an available port in range {preferred_port}-{preferred_port + max_attempts - 1}"+ )+++def format_port_sentinel(*, port: int) -> str:+ """Format the stdout line that Electron parses to discover the port."""+ return f"{PORT_SENTINEL}={port}"\ No newline at end of filediff --git a/freemocap/api/server/__init__.py b/freemocap/api/udp/__init__.pysimilarity index 100%rename from freemocap/api/server/__init__.pyrename to freemocap/api/udp/__init__.pydiff --git a/freemocap/api/udp/vmc_relay.py b/freemocap/api/udp/vmc_relay.pynew file mode 100644index 00000000..4855ca8b--- /dev/null+++ b/freemocap/api/udp/vmc_relay.py@@ -0,0 +1,90 @@+"""+VMC relay: app-level async task that broadcasts rigid body poses over UDP.++Runs independently of any browser/WebSocket connection. Polls the+application's frontend payload pipeline for new frames and sends+bone transforms via the VMC protocol.++The relay lazily creates and destroys its VMCSender based on the+live VMCSettings — toggling VMC on/off in the UI takes effect+within one poll cycle (~10ms).++Started by the FastAPI app lifespan and cancelled on shutdown.+"""+import asyncio+import logging++from freemocap.app.freemocap_application import FreemocapApplication, get_freemocap_app+from freemocap.app.settings import SettingsManager+from freemocap.core.mocap.skeleton_dewiggler.vmc_sender import VMCSender+from freemocap.core.viz.frontend_payload import FrontendPayload+from freemocap.utilities.wait_functions import await_10ms++logger = logging.getLogger(__name__)+++async def vmc_relay_task(+ *,+ app: FreemocapApplication,+) -> None:+ """Poll for new frames and broadcast rigid body poses via VMC/UDP.++ This task mirrors the websocket relay's polling pattern but sends+ over UDP instead of WebSocket, and runs regardless of whether any+ browser is connected.++ Args:+ app: The FreemocapApplication singleton (owns pipelines + settings).+ """+ settings_manager: SettingsManager = app.settings_manager+ sender: VMCSender | None = None+ last_sent_frame: int = -1++ logger.info("VMC relay task started")++ try:+ while app.should_continue:+ await await_10ms()++ # Sync sender lifecycle with settings+ vmc_settings = settings_manager.settings.vmc+ if vmc_settings.enabled:+ if (+ sender is None+ or sender._host != vmc_settings.host+ or sender._port != vmc_settings.port+ ):+ if sender is not None:+ sender.close()+ sender = VMCSender(host=vmc_settings.host, port=vmc_settings.port)+ else:+ if sender is not None:+ sender.close()+ sender = None+ continue # Nothing to do when disabled++ # Poll for new frames+ try:+ frontend_payloads = app.get_latest_frontend_payloads(+ if_newer_than=last_sent_frame,+ )+ except IndexError:+ last_sent_frame = -1+ continue++ for _pipeline_id, (_payload_bytes, frontend_payload) in frontend_payloads.items():+ if not isinstance(frontend_payload, FrontendPayload):+ continue+ if frontend_payload.rigid_body_poses:+ sender.send(frontend_payload.rigid_body_poses)+ last_sent_frame = frontend_payload.frame_number++ except asyncio.CancelledError:+ logger.info("VMC relay task cancelled")+ except Exception as e:+ logger.error(f"VMC relay task error: {e}", exc_info=True)+ raise+ finally:+ if sender is not None:+ sender.close()+ logger.info("VMC relay task stopped")diff --git a/freemocap/api/udp/vmc_test_receiver.py b/freemocap/api/udp/vmc_test_receiver.pynew file mode 100644index 00000000..72f4cc52--- /dev/null+++ b/freemocap/api/udp/vmc_test_receiver.py@@ -0,0 +1,135 @@+#!/usr/bin/env python3+"""+VMC test receiver: prints incoming bone transforms to the terminal.++Run this alongside freemocap with VMC enabled to verify data is flowing.+No dependencies beyond Python stdlib.++Usage:+ python vmc_test_receiver.py # listen on default port 39539+ python vmc_test_receiver.py 39540 # listen on custom port+"""++import socket+import struct+import sys+++def _read_osc_string(data: bytes, offset: int) -> tuple[str, int]:+ """Read a null-terminated, 4-byte-aligned OSC string."""+ end = data.index(b'\x00', offset)+ s = data[offset:end].decode('utf-8')+ # Advance past null + padding to 4-byte boundary+ padded_end = end + 1+ padded_end += (4 - padded_end % 4) % 4+ return s, padded_end+++def _read_osc_float(data: bytes, offset: int) -> tuple[float, int]:+ """Read a big-endian float32."""+ value = struct.unpack_from('>f', data, offset)[0]+ return value, offset + 4+++def parse_osc_message(data: bytes, offset: int = 0) -> dict | None:+ """Parse a single OSC message. Returns dict with address + args, or None."""+ if offset >= len(data):+ return None++ address, offset = _read_osc_string(data, offset)+ if offset >= len(data):+ return {'address': address, 'args': []}++ type_tag, offset = _read_osc_string(data, offset)+ if not type_tag.startswith(','):+ return {'address': address, 'args': []}++ args: list[str | float | int] = []+ for tag in type_tag[1:]: # skip the leading comma+ if tag == 'f':+ val, offset = _read_osc_float(data, offset)+ args.append(val)+ elif tag == 's':+ val, offset = _read_osc_string(data, offset)+ args.append(val)+ elif tag == 'i':+ val = struct.unpack_from('>i', data, offset)[0]+ offset += 4+ args.append(val)+ else:+ break # unknown type, stop parsing++ return {'address': address, 'args': args}+++def parse_bundle(data: bytes) -> list[dict]:+ """Parse an OSC bundle into a list of messages."""+ messages: list[dict] = []++ # Check for #bundle header+ if data[:8] != b'#bundle\x00':+ msg = parse_osc_message(data)+ if msg:+ messages.append(msg)+ return messages++ offset = 8 # skip "#bundle\0"+ offset += 8 # skip timetag++ while offset < len(data):+ if offset + 4 > len(data):+ break+ size = struct.unpack_from('>I', data, offset)[0]+ offset += 4+ if offset + size > len(data):+ break+ msg = parse_osc_message(data, offset)+ if msg:+ messages.append(msg)+ offset += size++ return messages+++def main() -> None:+ port = int(sys.argv[1]) if len(sys.argv) > 1 else 39539++ sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)+ sock.bind(('0.0.0.0', port))+ sock.settimeout(1.0)++ print(f"VMC test receiver listening on UDP port {port}")+ print(f"Waiting for /VMC/Ext/Bone/Pos messages...\n")++ frame_count = 0+ try:+ while True:+ try:+ data, addr = sock.recvfrom(65536)+ except socket.timeout:+ continue++ messages = parse_bundle(data)+ bone_messages = [m for m in messages if m['address'] == '/VMC/Ext/Bone/Pos']++ if bone_messages:+ frame_count += 1+ print(f"--- Frame {frame_count} ({len(bone_messages)} bones from {addr[0]}:{addr[1]}) ---")+ for msg in bone_messages:+ args = msg['args']+ if len(args) >= 8:+ name = args[0]+ px, py, pz = args[1], args[2], args[3]+ qx, qy, qz, qw = args[4], args[5], args[6], args[7]+ print(f" {name:20s} pos=({px:+7.3f}, {py:+7.3f}, {pz:+7.3f}) "+ f"quat=({qw:+6.3f}, {qx:+6.3f}, {qy:+6.3f}, {qz:+6.3f})")+ print()++ except KeyboardInterrupt:+ print(f"\nReceived {frame_count} frames total. Goodbye!")+ finally:+ sock.close()+++if __name__ == '__main__':+ main()diff --git a/freemocap/api/websocket/websocket_server.py b/freemocap/api/websocket/websocket_server.pyindex 0273142d..eabe8431 100644--- a/freemocap/api/websocket/websocket_server.py+++ b/freemocap/api/websocket/websocket_server.py@@ -1,33 +1,52 @@+"""+WebSocket server with settings sync integration.++Changes from original:+ - Accepts a SettingsManager and FreemocapApplication+ - Runs a _settings_state_relay task alongside existing tasks+ - _client_message_handler routes settings/* messages to settings_protocol+"""import asyncioimport jsonimport loggingfrom fastapi import FastAPI-from skellycam.core.recorders.framerate_tracker import FramerateTracker-from skellycam.core.types.type_overloads import CameraGroupIdString, CameraIdString+from skellycam.core.types.type_overloads import CameraIdStringfrom starlette.websockets import WebSocket, WebSocketState, WebSocketDisconnect-from freemocap.app.freemocap_application import FreemocApplication, get_freemocap_app-from freemocap.core.pipeline.frontend_payload import FrontendPayload-from freemocap.core.types.type_overloads import FrameNumberInt-from freemocap.system.logging_configuration.handlers.websocket_log_queue_handler import get_websocket_log_queue, \- MIN_LOG_LEVEL_FOR_WEBSOCKET+from freemocap.app.freemocap_application import FreemocapApplication, get_freemocap_app+from freemocap.app.settings_protocol import (+ handle_settings_message,+ settings_state_relay,+)+from freemocap.core.viz.frontend_payload import FrontendPayload+from freemocap.system.logging_configuration.handlers.websocket_log_queue_handler import (+ get_websocket_log_queue,+ MIN_LOG_LEVEL_FOR_WEBSOCKET,+)from freemocap.utilities.wait_functions import await_10ms+from typing import TYPE_CHECKING++if TYPE_CHECKING:+ from freemocap.app.settings import SettingsManager+ from skellycam.core.types.type_overloads import CameraGroupIdString+ from skellycam.core.recorders.framerate_tracker import FramerateTrackerlogger = logging.getLogger(__name__)-BACKPRESSURE_WARNING_THRESHOLD: int = 100 # Number of frames before we warn about backpressure+BACKPRESSURE_WARNING_THRESHOLD: int = 100class WebsocketServer:def __init__(self, fastapi_app: FastAPI, websocket: WebSocket):-self.websocket = websocketif not hasattr(fastapi_app, "state") or not hasattr(fastapi_app.state, "global_kill_flag"):raise RuntimeError(- "FastAPI app does not have a global_kill_flag in its state - define those fields when creating fastapi app")+ "FastAPI app does not have a global_kill_flag in its state"+ )self._global_kill_flag = fastapi_app.state.global_kill_flag- self._app: FreemocApplication = get_freemocap_app()+ self._app: FreemocapApplication = get_freemocap_app()+ self._settings_manager: SettingsManager = self._app.settings_managerself._websocket_should_continue = Trueself.ws_tasks: list[asyncio.Task] = []@@ -39,16 +58,15 @@ class WebsocketServer:async def __aenter__(self):logger.debug("Entering WebsocketRunner context manager...")self._websocket_should_continue = True+ # Sync settings from app state on connection+ self._settings_manager.update_from_app(self._app)return selfasync def __aexit__(self, exc_type, exc_val, exc_tb):logger.debug("WebsocketRunner context manager exiting...")self._websocket_should_continue = False-- # Only close if still connectedif self.websocket.client_state == WebSocketState.CONNECTED:await self.websocket.close()- # Cancel all tasksfor task in self.ws_tasks:if not task.done():task.cancel()@@ -57,22 +75,40 @@ class WebsocketServer:@propertydef should_continue(self):return (- not self._global_kill_flag.value- and self._websocket_should_continue- and self.websocket.client_state == WebSocketState.CONNECTED+ not self._global_kill_flag.value+ and self._websocket_should_continue+ and self.websocket.client_state == WebSocketState.CONNECTED)async def run(self):logger.info("Starting websocket runner...")- self.ws_tasks = [asyncio.create_task(self._frontend_image_relay(), name="WebsocketFrontendImageRelay"),- asyncio.create_task(self._logs_relay(), name="WebsocketLogsRelay"),- asyncio.create_task(self._client_message_handler(), name="WebsocketClientMessageHandler")]+ self.ws_tasks = [+ asyncio.create_task(+ self._frontend_image_relay(),+ name="WebsocketFrontendImageRelay",+ ),+ asyncio.create_task(+ self._logs_relay(),+ name="WebsocketLogsRelay",+ ),+ asyncio.create_task(+ self._client_message_handler(),+ name="WebsocketClientMessageHandler",+ ),+ asyncio.create_task(+ settings_state_relay(+ websocket=self.websocket,+ settings_manager=self._settings_manager,+ should_continue=lambda: self.should_continue,+ ),+ name="WebsocketSettingsStateRelay",+ ),+ ]try:await asyncio.gather(*self.ws_tasks, return_exceptions=True)except Exception as e:logger.exception(f"Error in websocket runner: {e.__class__}: {e}")- # Cancel all tasks when exitingfor task in self.ws_tasks:if not task.done():task.cancel()@@ -83,23 +119,29 @@ class WebsocketServer:return Truereturn self.last_received_frontend_confirmation >= self.last_sent_frame_number- # Updated section for _frontend_image_relay method in websocket_server.py-async def _frontend_image_relay(self) -> None:- """- Relay image payloads from the shared memory to the frontend via the websocket.- """- logger.info(f"Starting frontend image payload relay...")+ """Relay image payloads from shared memory to the frontend via WebSocket."""+ logger.info("Starting frontend image payload relay...")try:skipped_previous = Falsewhile self.should_continue:await await_10ms()- frontend_payloads = self._app.get_latest_frontend_payloads(if_newer_than=self.last_sent_frame_number)-if self.check_frame_acknowledgment_status():- if skipped_previous: # skip an extra frame if there was backpressure from frontend+ if skipped_previous:skipped_previous = Falseelse:+ try:+ frontend_payloads = self._app.get_latest_frontend_payloads(+ if_newer_than=self.last_sent_frame_number+ )+ except IndexError:+ logger.warning(+ f"Ring buffer overwrite detected (last_sent_frame_number={self.last_sent_frame_number}). "+ f"Resetting to latest frame."+ )+ self.last_sent_frame_number = -1+ continue+for pipeline_id, (payload_bytes, frontend_payload) in frontend_payloads.items():frame_number = Noneif not payload_bytes and not frontend_payload:@@ -111,32 +153,26 @@ class WebsocketServer:else:frame_number = frontend_payload.frame_number- if not isinstance(payload_bytes, (bytes, bytearray)):- logger.warning(f"Invalid payload bytes on frame{frame_number} -"- f" got type {type(payload_bytes)}")- continue-- # Send the image bytes firstif payload_bytes:+ if not isinstance(payload_bytes, (bytes, bytearray)):+ raise TypeError(+ f"Invalid payload bytes on frame {frame_number} - "+ f"got type {type(payload_bytes).__name__}"+ )await self.websocket.send_bytes(payload_bytes)- # Send observation overlays as a single message per observation type- if frontend_payload and frontend_payload.observation_overlays:- # Group overlays by message type- overlays_by_type: dict[str, dict[CameraIdString, dict]] = {}-- for camera_id, overlay_data in frontend_payload.observation_overlays.items():- message_type = overlay_data.message_type- if message_type not in overlays_by_type:- overlays_by_type[message_type] = {}- overlays_by_type[message_type][camera_id] = overlay_data.model_dump()+ if frontend_payload and frontend_payload.charuco_overlays:+ await self.websocket.send_json({+ camera_id: overlay_data.model_dump()+ for camera_id, overlay_data in frontend_payload.charuco_overlays.items()+ })- # Send each observation type as separate message- # This matches what the frontend expects- for message_type, camera_overlays in overlays_by_type.items():- await self.websocket.send_json(camera_overlays)+ if frontend_payload and frontend_payload.mediapipe_overlays:+ await self.websocket.send_json({+ camera_id: overlay_data.model_dump()+ for camera_id, overlay_data in frontend_payload.mediapipe_overlays.items()+ })- # Send tracked points if presentif frontend_payload and frontend_payload.tracked_points3d:points3d_dict = {point_name: tracked_point.model_dump()@@ -144,42 +180,57 @@ class WebsocketServer:}await self.websocket.send_json({"tracked_points3d": points3d_dict})+ if frontend_payload and frontend_payload.rigid_body_poses:+ rigid_body_dict = {+ bone_key: pose.model_dump()+ for bone_key, pose in frontend_payload.rigid_body_poses.items()+ }+ await self.websocket.send_json({"rigid_body_poses": rigid_body_dict})+if frame_number is not None:self.last_sent_frame_number = frame_numberelse:skipped_previous = Truebackpressure = self.last_sent_frame_number - self.last_received_frontend_confirmation- if (backpressure > BACKPRESSURE_WARNING_THRESHOLD and- backpressure % BACKPRESSURE_WARNING_THRESHOLD == 0):+ if (+ backpressure > BACKPRESSURE_WARNING_THRESHOLD+ and backpressure % BACKPRESSURE_WARNING_THRESHOLD == 0+ ):logger.trace(f"Backpressure detected: {backpressure} frames not acknowledged by frontend! "- f"Last sent frame: {self.last_sent_frame_number}, last received confirmation: "- f"{self.last_received_frontend_confirmation}")+ f"Last sent frame: {self.last_sent_frame_number}, "+ f"last received confirmation: {self.last_received_frontend_confirmation}"+ )except WebSocketDisconnect:logger.api("Client disconnected, ending Frontend Image relay task...")except asyncio.CancelledError:passexcept Exception as e:- logger.exception(f"Error in image payload relay: {e.__class__}: {e}")- self._global_kill_flag.value = True+ logger.exception(f"Error in frontend image relay: {e.__class__}: {e}")+ self._websocket_should_continue = Falseraise+async def _logs_relay(self, ws_log_level: int = MIN_LOG_LEVEL_FOR_WEBSOCKET):logger.info("Starting websocket log relay listener...")logs_queue = get_websocket_log_queue()try:while self.should_continue:if not logs_queue.empty() and self.websocket.client_state == WebSocketState.CONNECTED:- log_record: logging.LogRecord = logs_queue.get_nowait()- if log_record.levelno < ws_log_level:- continue # Skip logs below the specified level-- # if traceback is present, replace with string- if log_record.exc_info:- log_record.exc_text = logging.Formatter().formatException(log_record.exc_info)- log_record.exc_info = None- print("Sending log record via websocket:", log_record.getMessage())- await self.websocket.send_json(log_record)+ try:+ # Skellycam's WebSocketQueueHandler puts LogRecordModel dicts+ # into the queue via put_nowait(). On rare occasions a child+ # process exit (cancel_join_thread) can leave a partial pickle+ # in the pipe — the except below handles that gracefully.+ log_entry: dict = logs_queue.get_nowait()+ except (EOFError, OSError):+ # Partial write from a dying child process — skip it+ continue+ if not isinstance(log_entry, dict):+ continue+ if log_entry.get("levelno", 0) < ws_log_level:+ continue+ await self.websocket.send_json(log_entry)else:await await_10ms()except asyncio.CancelledError:@@ -188,50 +239,63 @@ class WebsocketServer:logger.info("Client disconnected, ending log relay task...")except Exception as e:logger.exception(f"Error in websocket log relay: {e.__class__}: {e}")- self._global_kill_flag.value = True+ self._websocket_should_continue = Falseraiseasync def _client_message_handler(self):- """- Handle messages from the client.- """+ """Handle messages from the client, including settings messages."""logger.info("Starting client message handler...")try:while self.should_continue:message = await self.websocket.receive()if message:+ msg_type = message.get("type", "")++ if msg_type == "websocket.disconnect":+ logger.info(f"Received websocket disconnect (code={message.get('code', 'unknown')})")+ self._websocket_should_continue = False+ break+if "text" in message:text_content = message.get("text", "")- # Try to parse as JSON if it looks like JSON- if text_content.strip().startswith('{') or text_content.strip().startswith('['):+ if text_content.strip().startswith("{") or text_content.strip().startswith("["):try:data = json.loads(text_content)- # Handle received_frame acknowledgment- if 'frameNumber' in data:- self.last_received_frontend_confirmation = data['frameNumber']- self._display_image_sizes = data.get('displayImageSizes', None)+ # Route settings messages to the settings protocol+ data_message_type = data.get("message_type", "")+ if data_message_type.startswith("settings/"):+ handle_settings_message(+ data=data,+ settings_manager=self._settings_manager,+ app=self._app,+ )+ elif "frameNumber" in data:+ # Existing frame acknowledgment handling+ self.last_received_frontend_confirmation = data["frameNumber"]+ self._display_image_sizes = data.get("displayImageSizes", None)+ else:+ logger.debug(f"Received unhandled JSON message: {list(data.keys())}")except json.JSONDecodeError as e:- logger.error(f"Failed to decode JSON message: {e}")+ raise ValueError(f"Failed to decode JSON message: {e}") from eelse:- # Handle plain text messagesif text_content.startswith("ping"):await self.websocket.send_text("pong")elif text_content.startswith("pong"):passelse:logger.info(f"Websocket received message: `{text_content}`")- elif "websocket" in message:- logger.trace(f"Received unknown websocket control message: {message}")+ elif "bytes" in message:+ logger.trace(f"Received binary websocket message ({len(message['bytes'])} bytes)")else:- logger.warning(f"Received unexpected message format: {message}")+ raise RuntimeError(f"Received unexpected message format: {message}")except asyncio.CancelledError:logger.debug("Client message handler task cancelled")except Exception as e:logger.exception(f"Error handling client message: {e.__class__}: {e}")- self._global_kill_flag.value = True+ self._websocket_should_continue = Falseraisefinally:- logger.info("Ending client message handler...")+ logger.info("Ending client message handler...")\ No newline at end of filediff --git a/freemocap/app/app.py b/freemocap/app/app.pyindex db0301ae..fef00d53 100644--- a/freemocap/app/app.py+++ b/freemocap/app/app.py@@ -4,9 +4,6 @@ Consolidated FastAPI app factory with proper lifecycle management.import asyncioimport loggingimport multiprocessing-import os-import signal-import timefrom contextlib import asynccontextmanagerfrom pathlib import Pathfrom typing import AsyncGenerator@@ -15,45 +12,26 @@ import skellycamfrom fastapi import FastAPIfrom fastapi.openapi.utils import get_openapifrom fastapi.responses import RedirectResponse+from skellycam.core.ipc.process_management.worker_registry import WorkerRegistryfrom starlette.responses import FileResponseimport freemocapfrom freemocap.api.http.app.health import health_routerfrom freemocap.api.http.app.shutdown import shutdown_router+from freemocap.api.http.app.state import state_routerfrom freemocap.api.middleware.add_middleware import add_middlewarefrom freemocap.api.middleware.cors import cors-from freemocap.api.routers import SKELLYCAM_ROUTERS, FREEMOCAP_ROUTERS-from freemocap.api.server_constants import APP_URL+from freemocap.api.routers import SKELLYCAM_ROUTERS, FREEMOCAP_ROUTERS, APP_ROUTERS+from freemocap.api.server_constants import PROTOCOL, HOSTNAME+from freemocap.api.udp.vmc_relay import vmc_relay_taskfrom freemocap.api.websocket.websocket_connect import websocket_routerfrom freemocap.app.freemocap_application import create_freemocap_app, get_freemocap_appfrom freemocap.system.default_paths import (get_default_freemocap_base_folder_path, FREEMOCAP_FAVICON_ICO_PATH)-from freemocap.utilities.wait_functions import await_1slogger = logging.getLogger(__name__)-async def keep_alive_task(*,- heartbeat_timestamp: multiprocessing.Value,- global_kill_flag: multiprocessing.Value) -> None:- """A simple task that increments a counter every second to indicate the main process is alive."""- logger.debug("Starting heartbeat task...")- while not global_kill_flag.value:- with heartbeat_timestamp.get_lock():- heartbeat_timestamp.value = time.perf_counter()- await asyncio.sleep(1.0)- logger.debug("Heartbeat task ended")--async def monitor_kill_flag(app: FastAPI) -> None:- """- Background task to monitor the kill flag and trigger shutdown.- """- while not app.state.global_kill_flag.value:- await await_1s()-- logger.info("Kill flag detected, initiating shutdown...")- os.kill(os.getpid(), signal.SIGTERM)-@asynccontextmanagerasync def app_lifespan(@@ -70,87 +48,42 @@ async def app_lifespan(base_path = Path(get_default_freemocap_base_folder_path())base_path.mkdir(parents=True, exist_ok=True)logger.info(f"Base folder: {base_path}")- create_freemocap_app(fastapi_app=app)- # Initialize heartbeat timestamp with current time- with app.state.heartbeat_timestamp.get_lock():- app.state.heartbeat_timestamp.value = time.perf_counter()-- # Start heartbeat task IN THE APP CONTEXT- heartbeat_task = asyncio.create_task(- keep_alive_task(- heartbeat_timestamp=app.state.heartbeat_timestamp,- global_kill_flag=app.state.global_kill_flag- )- )- # Start background task to monitor kill flag- monitor_task = asyncio.create_task(monitor_kill_flag(app=app))+ app_url = f"{PROTOCOL}://{HOSTNAME}:{app.state.port}"logger.success(f"FreeMoCap API {freemocap.__version__} started successfully 💀✨\n"- f"Swagger API docs: {APP_URL}/docs"+ f"Swagger API docs: {app_url}/docs")- # Let the application do its thingyield# ===== SHUTDOWN =====logger.api("FreeMoCap API shutting down...")- # Cancel the background tasks- heartbeat_task.cancel()- monitor_task.cancel()-- try:- await heartbeat_task- except asyncio.CancelledError:- pass-- try:- await monitor_task- except asyncio.CancelledError:- pass-- # Cleanup SkellyCam applicationapp.state.global_kill_flag.value = True- get_freemocap_app().close()logger.success("FreeMoCap API shutdown complete - Goodbye! 👋")-def create_fastapi_app(global_kill_flag: multiprocessing.Value,- heartbeat_timestamp: multiprocessing.Value,- subprocess_registry: list[multiprocessing.Process]) -> FastAPI:+def create_fastapi_app(+ *,+ global_kill_flag: multiprocessing.Value,+ worker_registry: WorkerRegistry,+ port: int,+) -> FastAPI:"""Create and configure the FastAPI application.-- Args:- global_kill_flag: Shared flag for coordinated shutdown- heartbeat_timestamp: Shared heartbeat timestamp value- subprocess_registry: List to track subprocesses-- Returns:- Configured FastAPI application"""- # Create app with lifespan managerapp = FastAPI(lifespan=app_lifespan)- # Store dependencies in app stateapp.state.global_kill_flag = global_kill_flag- app.state.subprocess_registry = subprocess_registry- app.state.heartbeat_timestamp = heartbeat_timestamp--- # Configure CORS+ app.state.worker_registry = worker_registry+ app.state.port = port+ create_freemocap_app(fastapi_app=app)cors(app)-- # Register routes_register_routes(app)-- # Add middlewareadd_middleware(app)-- # Customize OpenAPI_customize_openapi(app)return app@@ -173,9 +106,10 @@ def _register_routes(app: FastAPI) -> None:app.include_router(websocket_router)for route in websocket_router.routes:logger.api(f"\tRegistered WebSocket route: {route.path}")- # Health and shutdown routes (no prefix)++ # Health, shutdown, and settings state routes (no prefix)logger.api("\nRegistering App level routes:")- for router in [health_router, shutdown_router]:+ for router in APP_ROUTERS:app.include_router(router)for route in router.routes:logger.api(f"\tRegistered: {route.path} with methods: [{', '.join(route.methods)}]")@@ -214,4 +148,4 @@ def _customize_openapi(app: FastAPI) -> None:app.openapi_schema = schemareturn schema- app.openapi = custom_openapi+ app.openapi = custom_openapi\ No newline at end of filediff --git a/freemocap/app/freemocap_application.py b/freemocap/app/freemocap_application.pyindex 8c5f3c29..e2cab3ae 100644--- a/freemocap/app/freemocap_application.py+++ b/freemocap/app/freemocap_application.py@@ -1,32 +1,37 @@+"""+FreemocapApplication with SettingsManager integration.++"""import loggingimport multiprocessing-from dataclasses import dataclass+from dataclasses import dataclass, fieldfrom fastapi import FastAPIfrom pydantic import BaseModel, ConfigDictfrom skellycam.core.camera_group.camera_group import CameraGroupStatefrom skellycam.core.camera_group.camera_group_manager import CameraGroupManager, get_or_create_camera_group_manager+from skellycam.core.ipc.process_management.worker_registry import WorkerRegistryfrom skellycam.core.recorders.videos.recording_info import RecordingInfofrom skellycam.core.types.type_overloads import CameraGroupIdString-from freemocap.core.pipeline.frontend_payload import FrontendPayload-from freemocap.core.pipeline.pipeline_configs import RealtimePipelineConfig-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.posthoc_calibration_pipeline import \- CalibrationpipelineConfig-from freemocap.core.pipeline.posthoc_pipelines.posthoc_pipeline_manager import PosthocPipelineManager-from freemocap.core.pipeline.realtime_pipeline.realtime_pipeline import RealtimeProcessingPipeline-from freemocap.core.pipeline.realtime_pipeline.realtime_pipeline_manager import RealtimePipelineManager+from freemocap.core.pipeline.posthoc.posthoc_pipeline import PosthocPipeline+from freemocap.core.pipeline.posthoc.posthoc_pipeline_manager import PosthocPipelineManager+from freemocap.core.pipeline.realtime.realtime_pipeline import RealtimePipeline+from freemocap.core.pipeline.realtime.realtime_pipeline_manager import RealtimePipelineManager+from freemocap.app.settings import SettingsManager+from freemocap.core.viz.frontend_payload import FrontendPayload+from freemocap.core.pipeline.pipeline_configs import (+ CalibrationPipelineConfig,+ MocapPipelineConfig,+ RealtimePipelineConfig,+)from freemocap.core.types.type_overloads import PipelineIdString, FrameNumberIntlogger = logging.getLogger(__name__)class WorkerState(BaseModel):- """Serializable representation of a worker process state."""- model_config = ConfigDict(- validate_assignment=True,- frozen=True- )+ model_config = ConfigDict(frozen=True)pid: intname: stralive: bool@@ -34,121 +39,182 @@ class WorkerState(BaseModel):class AppState(BaseModel):- """Serializable representation of the application state."""- model_config = ConfigDict(- validate_assignment=True,- frozen=True- )- # pipelines: dict[PipelineIdString, PipelineState]+ model_config = ConfigDict(frozen=True)camera_groups: dict[CameraGroupIdString, CameraGroupState]workers: dict[str, WorkerState]@dataclass-class FreemocApplication:+class FreemocapApplication:+global_kill_flag: multiprocessing.Value- pipeline_shutdown_event: multiprocessing.Event+ worker_registry: WorkerRegistryrealtime_pipeline_manager: RealtimePipelineManagerposthoc_pipeline_manager: PosthocPipelineManagercamera_group_manager: CameraGroupManager+ settings_manager: SettingsManager = field(default_factory=SettingsManager)@classmethod- def create(cls, fastapi_app: FastAPI) -> 'FreemocApplication':-- return cls(global_kill_flag=fastapi_app.state.global_kill_flag,- pipeline_shutdown_event=multiprocessing.Event(),- realtime_pipeline_manager=RealtimePipelineManager.from_fastapi_app(fastapi_app),- posthoc_pipeline_manager=PosthocPipelineManager.from_fastapi_app(fastapi_app),- camera_group_manager=get_or_create_camera_group_manager(app=fastapi_app)- )+ def create(cls, fastapi_app: FastAPI) -> "FreemocapApplication":+ global_kill_flag = fastapi_app.state.global_kill_flag+ worker_registry = fastapi_app.state.worker_registry++ return cls(+ global_kill_flag=global_kill_flag,+ worker_registry=worker_registry,+ realtime_pipeline_manager=RealtimePipelineManager(+ worker_registry=worker_registry,+ ),+ posthoc_pipeline_manager=PosthocPipelineManager(+ global_kill_flag=global_kill_flag,+ worker_registry=worker_registry,+ ),+ camera_group_manager=get_or_create_camera_group_manager(app=fastapi_app),+ settings_manager=SettingsManager(),+ )@propertydef should_continue(self) -> bool:return not self.global_kill_flag.value- async def create_or_update_realtime_pipeline(self,- pipeline_config: RealtimePipelineConfig) -> RealtimeProcessingPipeline:- pipeline = self.realtime_pipeline_manager.get_pipeline_by_camera_ids(- camera_ids=pipeline_config.camera_ids)- if pipeline is not None:- pipeline = await self.realtime_pipeline_manager.update_realtime_pipeline(pipeline_config=pipeline_config)- else:- camera_group = await self.camera_group_manager.create_or_update_camera_group(- camera_configs=pipeline_config.camera_configs- )- pipeline = await self.realtime_pipeline_manager.create_realtime_pipeline(- camera_group=camera_group,- pipeline_config=pipeline_config)+ # ------------------------------------------------------------------+ # Realtime pipeline operations+ # ------------------------------------------------------------------++ async def create_or_update_realtime_pipeline(+ self,+ pipeline_config: RealtimePipelineConfig,+ ) -> RealtimePipeline:+ existing = self.realtime_pipeline_manager.get_pipeline_by_camera_ids(+ camera_ids=pipeline_config.camera_ids,+ )+ if existing is not None:+ existing.update_config(new_config=pipeline_config)+ self.settings_manager.update_from_app(self)+ return existing++ camera_group = await self.camera_group_manager.create_or_update_camera_group(+ camera_configs=pipeline_config.camera_configs,+ )+ pipeline = self.realtime_pipeline_manager.create_pipeline(+ camera_group=camera_group,+ pipeline_config=pipeline_config,+ )+ self.settings_manager.update_from_app(self)return pipeline- async def create_posthoc_calibration_pipeline(self,- recording_info: RecordingInfo,- calibration_pipeline_config:CalibrationpipelineConfig) -> RealtimeProcessingPipeline:- pipeline = await self.posthoc_pipeline_manager.create_posthoc_calibration_pipeline(+ # ------------------------------------------------------------------+ # Posthoc pipeline operations+ # ------------------------------------------------------------------++ async def create_posthoc_calibration_pipeline(+ self,+ recording_info: RecordingInfo,+ calibration_config: CalibrationPipelineConfig,+ ) -> PosthocPipeline:+ pipeline = self.posthoc_pipeline_manager.create_calibration_pipeline(recording_info=recording_info,- calibration_pipeline_config=calibration_pipeline_config+ calibration_config=calibration_config,)+ self.settings_manager.update_from_app(self)return pipeline- def close_pipelines(self):- self.realtime_pipeline_manager.close_all_realtime_pipelines()- self.posthoc_pipeline_manager.close_all_posthoc_pipelines()- def pause_unpause_pipelines(self):- self.realtime_pipeline_manager.pause_unpause_pipelines()+ async def create_posthoc_mocap_pipeline(+ self,+ recording_info: RecordingInfo,+ mocap_config: MocapPipelineConfig,+ ) -> PosthocPipeline:+ pipeline = self.posthoc_pipeline_manager.create_mocap_pipeline(+ recording_info=recording_info,+ mocap_config=mocap_config,+ )+ self.settings_manager.update_from_app(self)+ return pipeline- async def start_recording_all(self, recording_info: RecordingInfo):- await self.camera_group_manager.start_recording_all_groups(recording_info=recording_info)+ # ------------------------------------------------------------------+ # Recording orchestration+ # ------------------------------------------------------------------- async def stop_recording_all(self)-> RecordingInfo| None:- recording_infos = await self.camera_group_manager.stop_recording_all_groups()+ async def start_recording_all(self, recording_info: RecordingInfo) -> None:+ await self.camera_group_manager.start_recording_all_groups(+ recording_info=recording_info,+ )+ self.settings_manager.update_from_app(self)++ async def stop_recording_all(self) -> RecordingInfo | None:+ recording_infos = await self.camera_group_manager.stop_recording_all_groups()+ self.settings_manager.update_from_app(self)if len(recording_infos) == 0:- logger.warning(f"No recordings were stopped.")+ logger.warning("No recordings were stopped.")return None- elif len(recording_infos) >1:- raise NotImplementedError("Stopping multiple recordings at once is not supported yet.")+ if len(recording_infos) > 1:+ raise NotImplementedError(+ "Stopping multiple recordings at once is not supported yet."+ )return recording_infos[0]- def get_latest_frontend_payloads(self, if_newer_than: FrameNumberInt) -> dict[- PipelineIdString | CameraGroupIdString, tuple[bytes, FrontendPayload | FrameNumberInt]]:- if len(self.realtime_pipeline_manager.realtime_pipelines) == 0 or all(- [not p.alive for p in self.realtime_pipeline_manager.realtime_pipelines.values()]):- # if there are no pipelines, return the latest payloads from the camera groups instead- cg_payloads = self.camera_group_manager.get_latest_frontend_payloads(if_newer_than=if_newer_than)- cg_payloads = {camera_group_id: (payload[-1], payload[0]) for camera_group_id, payload in cg_payloads.items()}- return cg_payloads+ # ------------------------------------------------------------------+ # Frontend payloads+ # ------------------------------------------------------------------++ def get_latest_frontend_payloads(+ self,+ if_newer_than: FrameNumberInt,+ ) -> dict[PipelineIdString | CameraGroupIdString, tuple[bytes, FrontendPayload | FrameNumberInt]]:+ # Clean up completed posthoc pipelines (releases relay threads + queues)+ self.posthoc_pipeline_manager.evict_completed()++ realtime_pipelines = self.realtime_pipeline_manager.pipelines+ if len(realtime_pipelines) == 0 or all(+ not p.alive for p in realtime_pipelines.values()+ ):+ cg_payloads = self.camera_group_manager.get_latest_frontend_payloads(+ if_newer_than=if_newer_than,+ )+ return {+ camera_group_id: (payload[-1], payload[0])+ for camera_group_id, payload in cg_payloads.items()+ }- return self.realtime_pipeline_manager.get_latest_frontend_payloads(if_newer_than=if_newer_than)+ return self.realtime_pipeline_manager.get_latest_frontend_payloads(+ if_newer_than=if_newer_than,+ )- def close(self):- self.global_kill_flag.value = True- self.pipeline_shutdown_event.set()- self.realtime_pipeline_manager.close_all_realtime_pipelines()+ # ------------------------------------------------------------------+ # Lifecycle+ # ------------------------------------------------------------------- def to_app_state(self):- return AppState.from_app(self)+ def close_pipelines(self) -> None:+ self.realtime_pipeline_manager.shutdown()+ self.posthoc_pipeline_manager.shutdown()+ self.settings_manager.update_from_app(self)- async def create_or_update_realtime_calibration_pipeline(self, calibration_task_config: CalibrationpipelineConfig) -> RealtimeProcessingPipeline:- pipeline = await self.realtime_pipeline_manager.create_or_update_realtime_calibration_pipeline(- calibration_task_config=calibration_task_config- )- return pipeline+ def pause_unpause_pipelines(self) -> None:+ self.realtime_pipeline_manager.pause_unpause_all()+ self.settings_manager.update_from_app(self)+ def close(self) -> None:+ self.global_kill_flag.value = True+ self.realtime_pipeline_manager.shutdown()+ self.posthoc_pipeline_manager.shutdown()+ def to_app_state(self) -> AppState:+ return AppState.from_app(self)-FREEMOCAP_APP: FreemocApplication | None = None+FREEMOCAP_APP: FreemocapApplication | None = None-def create_freemocap_app(fastapi_app) -> FreemocApplication:++def create_freemocap_app(fastapi_app: FastAPI) -> FreemocapApplication:global FREEMOCAP_APP- if FREEMOCAP_APP is None:- FREEMOCAP_APP = FreemocApplication.create(fastapi_app=fastapi_app)- else:- raise ValueError("FreemocApp already exists!")+ if FREEMOCAP_APP is not None:+ raise RuntimeError("FreemocapApplication already exists!")+ FREEMOCAP_APP = FreemocapApplication.create(fastapi_app=fastapi_app)return FREEMOCAP_APP-def get_freemocap_app() -> FreemocApplication:+def get_freemocap_app() -> FreemocapApplication:global FREEMOCAP_APPif FREEMOCAP_APP is None:- raise ValueError("FreemocApp does not exist!")- return FREEMOCAP_APP+ raise RuntimeError("FreemocapApplication does not exist!")+ return FREEMOCAP_APP\ No newline at end of filediff --git a/freemocap/app/settings.py b/freemocap/app/settings.pynew file mode 100644index 00000000..fb72a7ff--- /dev/null+++ b/freemocap/app/settings.py@@ -0,0 +1,258 @@+"""+Unified application settings: the single serializable state blob+shared between frontend and backend over WebSocket.++Frontend can patch `config` sub-objects via `settings/patch` messages.+Runtime status fields are read-only from the frontend's perspective —+they are set by commands and hardware state changes on the backend.+"""+import asyncio+import logging+from enum import Enum++from pydantic import BaseModel, Field+from skellycam.core.camera.config.camera_config import CameraConfig, CameraConfigs+from skellycam.core.types.type_overloads import CameraIdString++from freemocap.core.pipeline.pipeline_configs import (+ CalibrationPipelineConfig,+ MocapPipelineConfig,+ RealtimePipelineConfig,+)++logger = logging.getLogger(__name__)+++# ---------------------------------------------------------------------------+# Sub-models: compose existing configs with runtime status+# ---------------------------------------------------------------------------+++class CameraStatus(str, Enum):+ DISCONNECTED = "disconnected"+ CONNECTED = "connected"+ ERROR = "error"+++class CameraState(BaseModel):+ """Per-camera config + runtime status."""+ config: CameraConfig+ status: CameraStatus = CameraStatus.DISCONNECTED+++class PipelineSettings(BaseModel):+ """Realtime pipeline config + runtime status."""+ config: RealtimePipelineConfig | None = None+ is_connected: bool = False+ pipeline_id: str | None = None+ camera_group_id: str | None = None+ is_paused: bool = False+++class CalibrationSettings(BaseModel):+ """Calibration config + runtime status."""+ config: CalibrationPipelineConfig = Field(default_factory=CalibrationPipelineConfig)+ is_recording: bool = False+ recording_progress: float = 0.0+ last_recording_path: str | None = None+ has_calibration_toml: bool = False+++class MocapSettings(BaseModel):+ """Motion capture config + runtime status."""+ config: MocapPipelineConfig = Field(default_factory=MocapPipelineConfig.default_realtime)+ is_recording: bool = False+ recording_progress: float = 0.0+ last_recording_path: str | None = None+++class VMCSettings(BaseModel):+ """VMC (Virtual Motion Capture) protocol output settings."""+ enabled: bool = False+ host: str = "127.0.0.1"+ port: int = 39539+++# ---------------------------------------------------------------------------+# Top-level settings blob+# ---------------------------------------------------------------------------+++class FreeMoCapSettings(BaseModel):+ """+ The authoritative, serializable application state.++ Sent in full over WebSocket as a `settings/state` message+ whenever any setting or runtime status changes.+ """+ cameras: dict[CameraIdString, CameraState] = Field(default_factory=dict)+ pipeline: PipelineSettings = Field(default_factory=PipelineSettings)+ calibration: CalibrationSettings = Field(default_factory=CalibrationSettings)+ mocap: MocapSettings = Field(default_factory=MocapSettings)+ vmc: VMCSettings = Field(default_factory=VMCSettings)+++# ---------------------------------------------------------------------------+# Settings Manager: owns the state, handles patches, notifies on change+# ---------------------------------------------------------------------------+++def _deep_merge(base: dict, patch: dict) -> dict:+ """+ RFC 7396 JSON Merge Patch: recursively merge patch into base.+ Keys in patch overwrite base. Nested dicts merge recursively.+ """+ result = base.copy()+ for key, value in patch.items():+ if isinstance(value, dict) and isinstance(result.get(key), dict):+ result[key] = _deep_merge(result[key], value)+ else:+ result[key] = value+ return result+++class SettingsManager:+ """+ Owns the authoritative FreeMoCapSettings instance.++ - Assembles current state from FreemocapApplication on demand.+ - Accepts patches from the frontend, validates, and applies them.+ - Provides an asyncio.Event for WebSocket tasks to await state changes.+ - Maintains a monotonic version counter for ordering.+ """++ def __init__(self) -> None:+ self._settings = FreeMoCapSettings()+ self._version: int = 0+ self._changed = asyncio.Event()++ @property+ def version(self) -> int:+ return self._version++ @property+ def settings(self) -> FreeMoCapSettings:+ return self._settings++ def get_state_message(self) -> dict:+ """Build a `settings/state` WebSocket message."""+ return {+ "message_type": "settings/state",+ "settings": self._settings.model_dump(),+ "version": self._version,+ }++ def notify_changed(self) -> None:+ """Bump version and wake any waiters."""+ self._version += 1+ self._changed.set()++ async def wait_for_change(self) -> None:+ """Block until notify_changed() is called. Clears the event after waking."""+ await self._changed.wait()+ self._changed.clear()++ def apply_patch(self, patch: dict) -> FreeMoCapSettings:+ """+ Apply a partial update (JSON merge-patch) to the current settings.++ Validates the result via Pydantic. If validation fails,+ the settings are left unchanged and the error is raised.+ """+ current = self._settings.model_dump()+ merged = _deep_merge(base=current, patch=patch)+ # Pydantic validates on construction — if this raises, settings are unchanged+ new_settings = FreeMoCapSettings.model_validate(merged)+ self._settings = new_settings+ self.notify_changed()+ logger.info(f"Settings patched (v{self._version}): {list(patch.keys())}")+ return self._settings++ def update_from_app(self, app: "FreemocapApplication") -> None:+ """+ Rebuild settings from the current application state.++ Call this after any command that changes runtime state+ (start recording, connect pipeline, etc.).+ """+ # Camera state+ cameras: dict[CameraIdString, CameraState] = {}+ for camera_group in app.camera_group_manager.camera_groups.values():+ for cam_id, cam_config in camera_group.configs.items():+ cameras[cam_id] = CameraState(+ config=cam_config,+ status=CameraStatus.CONNECTED,+ )++ # Pipeline state+ pipeline = PipelineSettings()+ realtime_pipelines = app.realtime_pipeline_manager.pipelines+ if realtime_pipelines:+ # Take the first active pipeline (single-pipeline assumption for now)+ first_pipeline = next(iter(realtime_pipelines.values()))+ pipeline = PipelineSettings(+ config=first_pipeline.config,+ is_connected=first_pipeline.alive,+ pipeline_id=first_pipeline.id,+ camera_group_id=first_pipeline.camera_group.id,+ )++ # Preserve user-set config values that aren't derived from runtime+ calibration = CalibrationSettings(+ config=self._settings.calibration.config,+ is_recording=self._settings.calibration.is_recording,+ recording_progress=self._settings.calibration.recording_progress,+ last_recording_path=self._settings.calibration.last_recording_path,+ has_calibration_toml=self._settings.calibration.has_calibration_toml,+ )++ mocap = MocapSettings(+ config=self._settings.mocap.config,+ is_recording=self._settings.mocap.is_recording,+ recording_progress=self._settings.mocap.recording_progress,+ last_recording_path=self._settings.mocap.last_recording_path,+ )++ self._settings = FreeMoCapSettings(+ cameras=cameras,+ pipeline=pipeline,+ calibration=calibration,+ mocap=mocap,+ vmc=self._settings.vmc,+ )+ self.notify_changed()++ def update_calibration_status(+ self,+ is_recording: bool | None = None,+ recording_progress: float | None = None,+ last_recording_path: str | None = None,+ has_calibration_toml: bool | None = None,+ ) -> None:+ """Update calibration runtime status fields and notify."""+ cal = self._settings.calibration+ if is_recording is not None:+ cal.is_recording = is_recording+ if recording_progress is not None:+ cal.recording_progress = recording_progress+ if last_recording_path is not None:+ cal.last_recording_path = last_recording_path+ if has_calibration_toml is not None:+ cal.has_calibration_toml = has_calibration_toml+ self.notify_changed()++ def update_mocap_status(+ self,+ is_recording: bool | None = None,+ recording_progress: float | None = None,+ last_recording_path: str | None = None,+ ) -> None:+ """Update mocap runtime status fields and notify."""+ moc = self._settings.mocap+ if is_recording is not None:+ moc.is_recording = is_recording+ if recording_progress is not None:+ moc.recording_progress = recording_progress+ if last_recording_path is not None:+ moc.last_recording_path = last_recording_path+ self.notify_changed()\ No newline at end of filediff --git a/freemocap/app/settings_protocol.py b/freemocap/app/settings_protocol.pynew file mode 100644index 00000000..5d92dbe3--- /dev/null+++ b/freemocap/app/settings_protocol.py@@ -0,0 +1,121 @@+"""+WebSocket settings protocol: handles settings/patch, settings/request,+and pushes settings/state on changes.++Runs as a task in WebsocketServer.run() alongside the existing+_frontend_image_relay, _logs_relay, and _client_message_handler tasks.+"""+import asyncio+import logging+from collections.abc import Callable+from copy import deepcopy++from starlette.websockets import WebSocket, WebSocketState++from freemocap.app.freemocap_application import FreemocapApplication+from freemocap.app.settings import SettingsManager++logger = logging.getLogger(__name__)+++async def settings_state_relay(+ websocket: WebSocket,+ settings_manager: SettingsManager,+ should_continue: Callable[[], bool],+) -> None:+ """+ Push `settings/state` to the frontend whenever settings change.++ Sends the full blob on startup (so the frontend gets initial state),+ then awaits the SettingsManager's change event and pushes again.+ """+ try:+ # Push initial state on connection+ if websocket.client_state == WebSocketState.CONNECTED:+ state_msg = settings_manager.get_state_message()+ await websocket.send_json(state_msg)+ logger.info("Sent initial settings/state")++ # Push on every subsequent change+ while should_continue():+ await settings_manager.wait_for_change()+ if websocket.client_state != WebSocketState.CONNECTED:+ break+ state_msg = settings_manager.get_state_message()+ await websocket.send_json(state_msg)+ logger.debug("Pushed settings/state")++ except asyncio.CancelledError:+ logger.debug("Settings state relay task cancelled")+ except Exception as e:+ logger.exception(f"Error in settings state relay: {e.__class__.__name__}: {e}")+ raise+++def handle_settings_message(+ data: dict,+ settings_manager: SettingsManager,+ app: FreemocapApplication,+) -> None:+ """+ Handle an incoming settings-related WebSocket message.++ Called from _client_message_handler when message_type starts with 'settings/'.++ Supported message_types:+ - settings/patch: apply a partial update to settings+ - settings/request: trigger a full state push (handled by notify)+ """+ message_type = data.get("message_type", "")++ if message_type == "settings/patch":+ patch = data.get("patch")+ if patch is None:+ raise ValueError("Received settings/patch with no 'patch' field")+ settings_manager.apply_patch(patch)+ # After applying config changes, sync relevant configs back+ # to the running pipelines/managers+ _sync_patch_to_app(patch=patch, settings_manager=settings_manager, app=app)++ elif message_type == "settings/request":+ # Frontend wants the full state — just notify so the relay task pushes it+ settings_manager.notify_changed()++ else:+ raise ValueError(f"Unknown settings message_type: {message_type}")+++def _sync_patch_to_app(+ patch: dict,+ settings_manager: SettingsManager,+ app: FreemocapApplication,+) -> None:+ """+ After a settings patch is applied, push relevant config changes+ into the running application components.++ This bridges the gap between "settings blob updated" and+ "actual pipeline/camera behavior changed."+ """+ # If calibration config was patched, update active pipelines+ if "calibration" in patch and "config" in patch.get("calibration", {}):+ cal_config = settings_manager.settings.calibration.config+ with app.realtime_pipeline_manager.lock:+ for pipeline in app.realtime_pipeline_manager.pipelines.values():+ new_config = deepcopy(pipeline.config)+ new_config.calibration_config = cal_config+ pipeline.update_config(new_config=new_config)+ logger.info("Synced calibration config to active pipelines")++ # If mocap config was patched, update active pipelines+ if "mocap" in patch and "config" in patch.get("mocap", {}):+ mocap_config = settings_manager.settings.mocap.config+ with app.realtime_pipeline_manager.lock:+ for pipeline in app.realtime_pipeline_manager.pipelines.values():+ new_config = deepcopy(pipeline.config)+ new_config.mocap_config = mocap_config+ pipeline.update_config(new_config=new_config)+ logger.info("Synced mocap config to active pipelines")++ # Camera config changes still go through the REST+ # /camera/group/apply endpoint for now.diff --git a/freemocap/core/blender/__init__.py b/freemocap/core/calibration/__init__.pysimilarity index 100%rename from freemocap/core/blender/__init__.pyrename to freemocap/core/calibration/__init__.pydiff --git a/freemocap/core/image_overlay/__init__.py b/freemocap/core/calibration/anipose_calibration/__init__.pysimilarity index 100%rename from freemocap/core/image_overlay/__init__.pyrename to freemocap/core/calibration/anipose_calibration/__init__.pydiff --git a/freemocap/core/calibration/anipose_calibration/anipose_adapters.py b/freemocap/core/calibration/anipose_calibration/anipose_adapters.pynew file mode 100644index 00000000..483e6845--- /dev/null+++ b/freemocap/core/calibration/anipose_calibration/anipose_adapters.py@@ -0,0 +1,81 @@+"""Adapter functions between shared Pydantic models and anipose-specific types.++These let the anipose solver keep its internal AniposeCameraGroup/AniposeCamera+classes while the rest of the system speaks CameraModel/CalibrationResult.+"""+from freemocap.core.calibration.anipose_calibration.helpers.freemocap_anipose import AniposeCharucoBoard, \+ AniposeCameraGroup, AniposeCamera+from freemocap.core.calibration.shared.calibration_models import CharucoBoardDefinition, CameraModel, CameraIntrinsics, \+ CameraExtrinsics+++def create_anipose_board(board: CharucoBoardDefinition) -> AniposeCharucoBoard:+ """Create an AniposeCharucoBoard from the shared board definition.++ The anipose solver needs AniposeCharucoBoard because it inherits+ detect_image / estimate_pose_rows / get_all_calibration_points+ from aniposelib.boards.CharucoBoard.+ """+ return AniposeCharucoBoard(+ squaresX=board.squares_x,+ squaresY=board.squares_y,+ square_length=board.square_length_mm,+ marker_length=board.marker_length_mm,+ marker_bits=board.marker_bits,+ dict_size=board.dict_size,+ )+++def camera_models_to_anipose_group(cameras: list[CameraModel]) -> AniposeCameraGroup:+ """Build an AniposeCameraGroup from unified CameraModel objects.++ Used when downstream code (e.g. triangulation) requires the anipose API.+ """+ anipose_cameras: list[AniposeCamera] = []+ for cam in cameras:+ ac = AniposeCamera(+ matrix=cam.intrinsics.to_camera_matrix(),+ dist=cam.intrinsics.to_dist_coeffs_5(),+ size=cam.image_size,+ rvec=cam.extrinsics.rodrigues_vector,+ tvec=cam.extrinsics.translation,+ name=cam.name,+ world_orientation=cam.extrinsics.world_orientation,+ world_position=cam.extrinsics.world_position,+ )+ anipose_cameras.append(ac)++ return AniposeCameraGroup(cameras=anipose_cameras)+++def anipose_group_to_camera_models(group: AniposeCameraGroup) -> list[CameraModel]:+ """Extract a list of CameraModel from an AniposeCameraGroup.++ Used after anipose calibration completes to produce a CalibrationResult.+ """+ cameras: list[CameraModel] = []+ for ac in group.cameras:+ intrinsics = CameraIntrinsics.from_camera_matrix_and_dist(+ camera_matrix=ac.get_camera_matrix(),+ dist_coeffs=ac.get_distortions(),+ )++ extrinsics = CameraExtrinsics.from_rodrigues(+ rvec=ac.get_rotation(),+ tvec=ac.get_translation(),+ )++ size = ac.get_size()+ if size is None:+ raise ValueError(f"AniposeCamera '{ac.get_name()}' has no image size set")++ cameras.append(+ CameraModel(+ name=ac.get_name(),+ image_size=(int(size[0]), int(size[1])),+ intrinsics=intrinsics,+ extrinsics=extrinsics,+ )+ )++ return camerasdiff --git a/freemocap/core/pipeline/posthoc_pipelines/__init__.py b/freemocap/core/calibration/anipose_calibration/helpers/__init__.pysimilarity index 100%rename from freemocap/core/pipeline/posthoc_pipelines/__init__.pyrename to freemocap/core/calibration/anipose_calibration/helpers/__init__.pydiff --git a/freemocap/core/calibration/anipose_calibration/helpers/calibration_helpers.py b/freemocap/core/calibration/anipose_calibration/helpers/calibration_helpers.pynew file mode 100644index 00000000..085c3de0--- /dev/null+++ b/freemocap/core/calibration/anipose_calibration/helpers/calibration_helpers.py@@ -0,0 +1,235 @@+"""Anipose calibration post-processing helpers.++Pin camera 0 to origin, charuco groundplane alignment,+real-world camera position computation.+"""++import logging+from pathlib import Path++import cv2+import numpy as np+import pandas as pd+from skellycam.core.types.type_overloads import CameraIdString+from skellytracker.trackers.base_tracker.base_tracker_abcs import BaseRecorder+from skellytracker.trackers.charuco_tracker.charuco_observation import CharucoObservation++from freemocap.core.calibration.anipose_calibration.helpers.freemocap_anipose import AniposeCameraGroup, \+ AniposeCharucoBoard+from freemocap.core.calibration.shared.groundplane_math import find_still_charuco_frame, CharucoVisibilityError, \+ CharucoVelocityError, compute_board_basis_vectors+from freemocap.core.types.type_overloads import VideoIdString++logger = logging.getLogger(__name__)++CharucoObservations = dict[CameraIdString, CharucoObservation | None]+++class GroundPlaneSuccess:+ def __init__(self, success: bool, error: str | None = None):+ self.success = success+ self.error = error+++def interpolate_skeleton_data(skeleton_data: np.ndarray, method_to_use: str = "linear", order: int = 3) -> np.ndarray:+ """Interpolate missing NaN values in a 3D skeleton/charuco numpy array.++ Args:+ skeleton_data: (n_frames, n_markers, 3) array with possible NaN gaps.+ method_to_use: Pandas interpolation method (e.g. 'linear', 'polynomial').+ order: Order for polynomial/spline interpolation methods.++ Returns:+ Interpolated array with same shape, NaN gaps filled.+ """+ num_frames = skeleton_data.shape[0]+ num_markers = skeleton_data.shape[1]+ interpolated = np.empty((num_frames, num_markers, 3))++ for marker in range(num_markers):+ marker_data = skeleton_data[:, marker, :]+ df = pd.DataFrame(marker_data)+ df_interpolated = df.interpolate(method=method_to_use, axis=0, order=order)+ marker_array = np.array(df_interpolated)+ # Fill remaining NaNs (e.g. at recording start) with column mean+ marker_array = np.where(+ np.isfinite(marker_array),+ marker_array,+ np.nanmean(marker_array),+ )+ interpolated[:, marker, :] = marker_array++ return interpolated+++def anipose_pin_camera_zero_to_origin(camera_group: AniposeCameraGroup) -> AniposeCameraGroup:+ """Re-express all camera extrinsics relative to camera 0.++ Camera 0 ends up with identity rotation and zero translation.+ All other cameras are expressed relative to camera 0.+ """+ rvecs_new = _align_rotations_to_cam0(camera_group=camera_group)+ camera_group.set_rotations(rvecs_new)+ tvecs_new = _shift_origin_to_cam0(camera_group=camera_group)+ camera_group.set_translations(tvecs_new)+ return camera_group+++def _align_rotations_to_cam0(camera_group: AniposeCameraGroup) -> np.ndarray:+ """Align all camera rotations to camera 0's coordinate frame."""+ rvecs = camera_group.get_rotations()+ R0, _ = cv2.Rodrigues(rvecs[0])++ rvecs_new = np.empty_like(rvecs)+ for i in range(rvecs.shape[0]):+ Ri, _ = cv2.Rodrigues(rvecs[i])+ Ri_new, _ = cv2.Rodrigues(Ri @ R0.T)+ rvecs_new[i] = Ri_new.flatten()+ return rvecs_new+++def _shift_origin_to_cam0(camera_group: AniposeCameraGroup) -> np.ndarray:+ """Shift world origin to camera 0's position."""+ tvecs = camera_group.get_translations()+ rvecs = camera_group.get_rotations()++ R0, _ = cv2.Rodrigues(rvecs[0, :])+ delta_to_origin_world = -R0.T @ tvecs[0, :]++ new_tvecs = np.zeros_like(tvecs)+ for cam_i in range(tvecs.shape[0]):+ Ri, _ = cv2.Rodrigues(rvecs[cam_i, :])+ delta_to_origin_camera_i = Ri @ delta_to_origin_world+ new_tvecs[cam_i, :] = tvecs[cam_i, :] + delta_to_origin_camera_i+ return new_tvecs+++def set_charuco_board_as_groundplane(+ *,+ observation_recorders: dict[VideoIdString, BaseRecorder],+ anipose_camera_group: AniposeCameraGroup,+ anipose_charuco_board: AniposeCharucoBoard,+ recording_folder_path: "Path | None" = None,+) -> tuple[AniposeCameraGroup, GroundPlaneSuccess]:+ """Set the charuco board plane as the world groundplane."""+ logger.info("Getting 2D Charuco data")+ data2d_by_video: dict[VideoIdString, np.ndarray] = {}+ if len(observation_recorders) == 0:+ raise ValueError("No observation recorders provided to process.")++ for video_id, recorder in observation_recorders.items():+ if not all(isinstance(observation, CharucoObservation) for observation in recorder.observations):+ raise TypeError(f"Recorder for video ID {video_id} contains non-Charuco observations.")+ data2d_fr_id_xyc = recorder.to_array.copy()+ logger.info(f"Processing video ID: {video_id} with 2D data shape: {data2d_fr_id_xyc.shape}")+ data2d_by_video[video_id] = data2d_fr_id_xyc[..., :2]++ charuco2d_cam_fr_id_xy = np.stack(list(data2d_by_video.values()), axis=0)+ logger.info(+ f"Charuco 2d data retrieved with shape (cams, frames, markers, XY): {charuco2d_cam_fr_id_xy.shape}"+ )+ charuco2d_cam_fr_id_xy = charuco2d_cam_fr_id_xy.astype(np.float64)+ num_cameras, num_frames, num_tracked_points, _ = charuco2d_cam_fr_id_xy.shape+ charuco_2d_flat = charuco2d_cam_fr_id_xy.reshape(num_cameras, -1, 2)++ logger.info("Getting 3d Charuco data")+ charuco_3d_flat = anipose_camera_group.triangulate(charuco_2d_flat)+ charuco3d_fr_id_xyz = charuco_3d_flat.reshape(num_frames, num_tracked_points, 3)+ logger.info(f"Charuco 3d data reconstructed with shape: {charuco3d_fr_id_xyz.shape}")++ charuco_3d_xyz_interpolated = interpolate_skeleton_data(skeleton_data=charuco3d_fr_id_xyz)++ try:+ charuco_still_frame_idx = find_still_charuco_frame(+ charuco_3d=charuco3d_fr_id_xyz,+ squares_x=anipose_charuco_board.squaresX,+ squares_y=anipose_charuco_board.squaresY,+ )+ except CharucoVisibilityError as e:+ logger.warning("Ground-plane alignment skipped — reverting to original calibration: %s", e, exc_info=True)+ return anipose_camera_group, GroundPlaneSuccess(success=False, error=str(e))+ except CharucoVelocityError as e:+ logger.warning("Ground-plane alignment skipped — reverting to original calibration: %s", e, exc_info=True)+ return anipose_camera_group, GroundPlaneSuccess(success=False, error=str(e))++ charuco_frame = charuco_3d_xyz_interpolated[charuco_still_frame_idx]++ x_hat, y_hat, z_hat = compute_board_basis_vectors(+ charuco_frame=charuco_frame,+ squares_x=anipose_charuco_board.squaresX,+ squares_y=anipose_charuco_board.squaresY,+ )++ charuco_origin_in_world = charuco_frame[0]+ rmat_charuco_to_world = np.column_stack([x_hat, y_hat, z_hat])++ rvecs_new, tvecs_new = _adjust_world_reference_frame_to_charuco(+ camera_group=anipose_camera_group,+ charuco_origin_in_world=charuco_origin_in_world,+ rmat_charuco_to_world=rmat_charuco_to_world,+ )++ anipose_camera_group.set_rotations(rvecs_new)+ anipose_camera_group.set_translations(tvecs_new)++ logger.info("Anipose camera calibration data adjusted to set charuco board as ground plane")++ # Recalculate 3D charuco data in new coordinate system+ charuco_3d_flat = anipose_camera_group.triangulate(charuco_2d_flat)+ charuco3d_fr_id_xyz = charuco_3d_flat.reshape(num_frames, num_tracked_points, 3)+ charuco_3d_xyz_interpolated = interpolate_skeleton_data(skeleton_data=charuco3d_fr_id_xyz)++ if recording_folder_path is not None:+ charuco_save_path = Path(recording_folder_path) / "output_data" / "charuco_3d_xyz.npy"+ charuco_save_path.parent.mkdir(parents=True, exist_ok=True)+ np.save(charuco_save_path, charuco_3d_xyz_interpolated)+ logger.info(f"Charuco 3d data saved to {charuco_save_path}")++ return anipose_camera_group, GroundPlaneSuccess(success=True)+++def _adjust_world_reference_frame_to_charuco(+ *,+ camera_group: AniposeCameraGroup,+ charuco_origin_in_world: np.ndarray,+ rmat_charuco_to_world: np.ndarray,+) -> tuple[np.ndarray, np.ndarray]:+ """Adjust camera extrinsics to use charuco board as world reference frame."""+ tvecs = camera_group.get_translations()+ rvecs = camera_group.get_rotations()++ tvecs_new = np.zeros_like(tvecs)+ rvecs_new = np.zeros_like(rvecs)++ for i in range(tvecs.shape[0]):+ rmat_world_to_cam_i, _ = cv2.Rodrigues(rvecs[i])+ t_delta = rmat_world_to_cam_i @ charuco_origin_in_world+ tvecs_new[i] = t_delta + tvecs[i]++ new_rmat = rmat_world_to_cam_i @ rmat_charuco_to_world+ new_rvec, _ = cv2.Rodrigues(new_rmat)+ rvecs_new[i] = new_rvec.flatten()++ return rvecs_new, tvecs_new+++def get_real_world_matrices(camera_group: AniposeCameraGroup) -> tuple[list, list]:+ """Calculate real-world positions and orientations of cameras."""+ rvecs = camera_group.get_rotations()+ tvecs = camera_group.get_translations()++ positions = []+ orientations = []++ for i in range(tvecs.shape[0]):+ rmat_world_to_cam_i, _ = cv2.Rodrigues(rvecs[i])+ rmat_cam_to_world = rmat_world_to_cam_i.T+ t_world = -rmat_cam_to_world @ tvecs[i]++ positions.append(t_world.astype(float).tolist())+ orientations.append(rmat_cam_to_world.astype(float).tolist())++ camera_group.set_world_positions(positions)+ camera_group.set_world_orientations(orientations)++ return positions, orientationsdiff --git a/freemocap/core/calibration/anipose_calibration/helpers/freemocap_anipose.py b/freemocap/core/calibration/anipose_calibration/helpers/freemocap_anipose.pynew file mode 100644index 00000000..3024a26f--- /dev/null+++ b/freemocap/core/calibration/anipose_calibration/helpers/freemocap_anipose.py@@ -0,0 +1,1129 @@+# Adapted (with permission) from the original `aniposelib` package+# (https://github.com/lambdaloop/aniposelib).+# More info on Anipose: https://anipose.readthedocs.io/en/latest/++import logging+import multiprocessing+from collections import defaultdict+from copy import copy+from pathlib import Path+from typing import Optional++import cv2+import numpy as np+import toml+from aniposelib.boards import extract_points, extract_rtvecs, merge_rows, CharucoBoard+from numba import jit+from scipy import optimize+from scipy.sparse import dok_matrix+from tqdm import trange++from freemocap.core.calibration.shared.transform_math import build_maximum_spanning_tree, make_M, \+ robust_average_transforms, find_spanning_tree_pairs, get_rtvec++numba_logger = logging.getLogger("numba")+numba_logger.setLevel(logging.WARNING)++logger = logging.getLogger(__name__)++ARUCO_DICTS = {+ (4, 50): cv2.aruco.DICT_4X4_50,+ (5, 50): cv2.aruco.DICT_5X5_50,+ (6, 50): cv2.aruco.DICT_6X6_50,+ (7, 50): cv2.aruco.DICT_7X7_50,+ (4, 100): cv2.aruco.DICT_4X4_100,+ (5, 100): cv2.aruco.DICT_5X5_100,+ (6, 100): cv2.aruco.DICT_6X6_100,+ (7, 100): cv2.aruco.DICT_7X7_100,+ (4, 250): cv2.aruco.DICT_4X4_250,+ (5, 250): cv2.aruco.DICT_5X5_250,+ (6, 250): cv2.aruco.DICT_6X6_250,+ (7, 250): cv2.aruco.DICT_7X7_250,+ (4, 1000): cv2.aruco.DICT_4X4_1000,+ (5, 1000): cv2.aruco.DICT_5X5_1000,+ (6, 1000): cv2.aruco.DICT_6X6_1000,+ (7, 1000): cv2.aruco.DICT_7X7_1000,+}+++# =============================================================================+# TRIANGULATION & REPROJECTION HELPERS+# =============================================================================+++def triangulate_simple(points: np.ndarray, camera_mats: np.ndarray) -> np.ndarray:+ """Triangulate a single 3D point from 2D observations via DLT."""+ num_cams = len(camera_mats)+ A = np.zeros((num_cams * 2, 4))+ for i in range(num_cams):+ x, y = points[i]+ mat = camera_mats[i]+ A[(i * 2): (i * 2 + 1)] = x * mat[2] - mat[0]+ A[(i * 2 + 1): (i * 2 + 2)] = y * mat[2] - mat[1]+ u, s, vh = np.linalg.svd(A, full_matrices=True)+ p3d = vh[-1]+ p3d = p3d[:3] / p3d[3]+ return p3d+++def get_error_dict(errors_full: np.ndarray, min_points: int = 10) -> dict:+ """Compute pairwise reprojection error statistics across cameras."""+ n_cams = errors_full.shape[0]+ errors_norm = np.linalg.norm(errors_full, axis=2)+ good = ~np.isnan(errors_full[:, :, 0])+ error_dict = dict()++ for i in range(n_cams):+ for j in range(i + 1, n_cams):+ subset = good[i] & good[j]+ err_subset = errors_norm[:, subset][[i, j]]+ err_subset_mean = np.mean(err_subset, axis=0)+ if np.sum(subset) > min_points:+ percents = np.percentile(err_subset_mean, [15, 75])+ error_dict[(i, j)] = (err_subset.shape[1], percents)+ return error_dict+++def subset_extra(extra: dict | None, ixs: np.ndarray) -> dict | None:+ """Subset the extra data dict (board IDs, object points, etc.) by indices."""+ if extra is None:+ return None+ return {+ "objp": extra["objp"][ixs],+ "ids": extra["ids"][ixs],+ "rvecs": extra["rvecs"][:, ixs],+ "tvecs": extra["tvecs"][:, ixs],+ }+++def resample_points(+ imgp: np.ndarray,+ extra: dict | None = None,+ n_samp: int = 25,+) -> tuple[np.ndarray, dict | None]:+ """Subsample 2D points for bundle adjustment, prioritizing multi-camera coverage."""+ n_cams = imgp.shape[0]+ good = ~np.isnan(imgp[:, :, 0])+ ixs = np.arange(imgp.shape[1])+ num_cams = np.sum(~np.isnan(imgp[:, :, 0]), axis=0)++ include: set[int] = set()++ for i in range(n_cams):+ for j in range(i + 1, n_cams):+ subset = good[i] & good[j]+ n_good = np.sum(subset)+ if n_good > 0:+ arr = np.copy(num_cams[subset]).astype("float64")+ arr += np.random.random(size=arr.shape)+ picked_ix = np.argsort(-arr)[:n_samp]+ picked = ixs[subset][picked_ix]+ include.update(picked)++ final_ixs = sorted(include)+ newp = imgp[:, final_ixs]+ extra = subset_extra(extra, final_ixs)+ return newp, extra+++def transform_points(+ points: np.ndarray,+ rvecs: np.ndarray,+ tvecs: np.ndarray,+) -> np.ndarray:+ """Rotate points by Rodrigues vectors and translate."""+ theta = np.linalg.norm(rvecs, axis=1)[:, np.newaxis]+ with np.errstate(invalid="ignore"):+ v = rvecs / theta+ v = np.nan_to_num(v)+ dot = np.sum(points * v, axis=1)[:, np.newaxis]+ cos_theta = np.cos(theta)+ sin_theta = np.sin(theta)++ rotated = cos_theta * points + sin_theta * np.cross(v, points) + dot * (1 - cos_theta) * v+ return rotated + tvecs+++def remap_ids(ids: np.ndarray) -> np.ndarray:+ """Remap arbitrary board IDs to contiguous 0-based indices."""+ unique_ids = np.unique(ids)+ ids_out = np.copy(ids)+ for i, num in enumerate(unique_ids):+ ids_out[ids == num] = i+ return ids_out+++# =============================================================================+# CAMERA GRAPH & EXTRINSICS INITIALIZATION+# =============================================================================+++def get_connections(+ xs: np.ndarray,+ cam_names: list | None = None,+ both: bool = True,+) -> dict[tuple, int]:+ """Count shared observation pairs between cameras."""+ n_cams = xs.shape[0]+ n_points = xs.shape[1]++ if cam_names is None:+ cam_names = [str(i) for i in range(n_cams)]++ connections: dict[tuple, int] = defaultdict(int)++ for rnum in range(n_points):+ ixs = np.where(~np.isnan(xs[:, rnum, 0]))[0]+ keys = [cam_names[ix] for ix in ixs]+ for i in range(len(keys)):+ for j in range(i + 1, len(keys)):+ a = keys[i]+ b = keys[j]+ connections[(a, b)] += 1+ if both:+ connections[(b, a)] += 1++ return connections+++def get_calibration_graph(+ rtvecs: np.ndarray,+ cam_names: np.ndarray | list | None = None,+) -> dict[int, list[int]]:+ """Build a maximum spanning tree of camera connections from shared observations."""+ n_cams = rtvecs.shape[0]+ if cam_names is None:+ cam_names = np.arange(n_cams)++ connections = get_connections(rtvecs, np.arange(n_cams))++ return build_maximum_spanning_tree(+ connection_counts=connections,+ n_nodes=n_cams,+ node_labels=[str(cn) for cn in cam_names],+ )+++def _get_pairwise_transform(rtvecs: np.ndarray, left: int, right: int) -> np.ndarray:+ """Compute the robust average transform between two cameras from shared observations.++ For each frame where both cameras observe the board, computes M_left @ inv(M_right)+ and robustly averages the results.+ """+ transforms: list[np.ndarray] = []++ for dix in range(rtvecs.shape[1]):+ d = rtvecs[:, dix]+ good = ~np.isnan(d[:, 0])+ if good[left] and good[right]:+ M_left = make_M(d[left, 0:3], d[left, 3:6])+ M_right = make_M(d[right, 0:3], d[right, 3:6])+ transforms.append(M_left @ np.linalg.inv(M_right))++ if len(transforms) == 0:+ raise ValueError(f"No shared observations between cameras {left} and {right}")++ logger.info(f"Camera pair ({left}, {right}): {len(transforms)} shared frames")+ return robust_average_transforms(transforms)+++def compute_camera_matrices(+ rtvecs: np.ndarray,+ pairs: list[tuple[int, int]],+) -> dict[int, np.ndarray]:+ """Compute camera extrinsics by chaining pairwise transforms along spanning tree pairs.++ Camera at pairs[0][0] is the root (identity transform).+ """+ extrinsics: dict[int, np.ndarray] = {}+ source = pairs[0][0]+ extrinsics[source] = np.identity(4)++ for a, b in pairs:+ if a not in extrinsics:+ raise ValueError(f"Camera {a} must be computed before camera {b}")+ ext = _get_pairwise_transform(rtvecs, b, a)+ extrinsics[b] = ext @ extrinsics[a]++ return extrinsics+++def get_initial_extrinsics(+ rtvecs: np.ndarray,+ cam_names: list | None = None,+) -> tuple[np.ndarray, np.ndarray]:+ """Compute initial camera extrinsics from board pose observations.++ Builds a spanning tree from shared observation counts, computes pairwise+ transforms, and chains them from camera 0 (the root).++ Returns:+ Tuple of (rvecs, tvecs) arrays, each shape (n_cams, 3).+ """+ n_cams = rtvecs.shape[0]+ n_frames = rtvecs.shape[1]+ logger.info(f"Computing initial extrinsics for {n_cams} cameras from {n_frames} frames")++ for cam_idx in range(n_cams):+ valid_obs = np.sum(~np.isnan(rtvecs[cam_idx, :, 0]))+ cam_name = cam_names[cam_idx] if cam_names else str(cam_idx)+ logger.info(f"Camera {cam_name}: {valid_obs}/{n_frames} valid observations ({100 * valid_obs / n_frames:.1f}%)")++ graph = get_calibration_graph(rtvecs, cam_names)+ logger.info(f"Calibration graph: {dict(graph)}")++ pairs = find_spanning_tree_pairs(graph, root=0)+ logger.info(f"Calibration pairs: {pairs}")++ if len(pairs) != n_cams - 1:+ raise ValueError(f"Expected {n_cams - 1} pairs, got {len(pairs)}. Graph may be disconnected!")++ extrinsics = compute_camera_matrices(rtvecs, pairs)++ rvecs = []+ tvecs = []+ for cnum in range(n_cams):+ if cnum not in extrinsics:+ raise ValueError(f"Missing extrinsics for camera {cnum}")+ rvec, tvec = get_rtvec(extrinsics[cnum])+ rvecs.append(rvec)+ tvecs.append(tvec)++ rvecs_arr = np.array(rvecs)+ tvecs_arr = np.array(tvecs)++ logger.info(f"Rotation magnitudes: {np.linalg.norm(rvecs_arr, axis=1)}")+ logger.info(f"Translation magnitudes: {np.linalg.norm(tvecs_arr, axis=1)}")++ return rvecs_arr, tvecs_arr+++# =============================================================================+# CAMERA MODEL+# =============================================================================+++class AniposeCamera:+ def __init__(+ self,+ matrix=np.eye(3),+ dist=np.zeros(5),+ size=None,+ rvec=np.zeros(3),+ tvec=np.zeros(3),+ world_orientation=np.eye(3),+ world_position=np.zeros(3),+ name=None,+ extra_dist=False,+ ):+ self.set_camera_matrix(matrix)+ self.set_distortions(dist)+ self.set_size(size)+ self.set_rotation(rvec)+ self.set_translation(tvec)+ self.set_world_orientation(world_orientation)+ self.set_world_position(world_position)+ self.set_name(name)+ self.extra_dist = extra_dist++ def get_dict(self) -> dict:+ return {+ "name": self.get_name(),+ "size": list(self.get_size()),+ "matrix": self.get_camera_matrix().tolist(),+ "distortions": self.get_distortions().tolist(),+ "rotation": self.get_rotation().tolist(),+ "translation": self.get_translation().tolist(),+ "world_orientation": self.get_world_orientation().tolist(),+ "world_position": self.get_world_position().tolist(),+ }++ def load_dict(self, d: dict) -> None:+ self.set_camera_matrix(d["matrix"])+ self.set_rotation(d["rotation"])+ self.set_translation(d["translation"])+ self.set_distortions(d["distortions"])+ self.set_name(d["name"])+ self.set_size(d["size"])+ self.set_world_orientation(d.get("world_orientation", np.eye(3)))+ self.set_world_position(d.get("world_position", np.zeros(3)))++ @staticmethod+ def from_dict(d: dict) -> "AniposeCamera":+ cam = AniposeCamera()+ cam.load_dict(d)+ return cam++ def get_camera_matrix(self) -> np.ndarray:+ return self.matrix++ def get_distortions(self) -> np.ndarray:+ return self.dist++ def set_camera_matrix(self, matrix) -> None:+ self.matrix = np.array(matrix, dtype="float64")++ def set_focal_length(self, fx: float, fy: float | None = None) -> None:+ if fy is None:+ fy = fx+ self.matrix[0, 0] = fx+ self.matrix[1, 1] = fy++ def get_focal_length(self, both: bool = False) -> float | tuple[float, float]:+ fx = self.matrix[0, 0]+ fy = self.matrix[1, 1]+ if both:+ return (fx, fy)+ else:+ return (fx + fy) / 2.0++ def set_distortions(self, dist) -> None:+ self.dist = np.array(dist, dtype="float64").ravel()++ def set_rotation(self, rvec) -> None:+ self.rvec = np.array(rvec, dtype="float64").ravel()++ def get_rotation(self) -> np.ndarray:+ return self.rvec++ def set_translation(self, tvec) -> None:+ self.tvec = np.array(tvec, dtype="float64").ravel()++ def get_translation(self) -> np.ndarray:+ return self.tvec++ def set_world_orientation(self, world_orientation) -> None:+ self.world_orientation = np.asarray(world_orientation, dtype="float64").reshape(3, 3)++ def get_world_orientation(self) -> np.ndarray:+ return self.world_orientation++ def set_world_position(self, world_position) -> None:+ self.world_position = np.array(world_position, dtype="float64").ravel()++ def get_world_position(self) -> np.ndarray:+ return self.world_position++ def get_extrinsics_mat(self) -> np.ndarray:+ return make_M(self.rvec, self.tvec)++ def get_name(self) -> str:+ return self.name++ def set_name(self, name) -> None:+ self.name = str(name)++ def set_size(self, size) -> None:+ """Set size as (width, height)."""+ self.size = size++ def get_size(self):+ """Get size as (width, height)."""+ return self.size++ def get_params(self) -> np.ndarray:+ params = np.zeros(8 + self.extra_dist, dtype="float64")+ params[0:3] = self.get_rotation()+ params[3:6] = self.get_translation()+ params[6] = self.get_focal_length()+ dist = self.get_distortions()+ params[7] = dist[0]+ if self.extra_dist:+ params[8] = dist[1]+ return params++ def set_params(self, params: np.ndarray) -> None:+ self.set_rotation(params[0:3])+ self.set_translation(params[3:6])+ self.set_focal_length(params[6])++ dist = np.zeros(5, dtype="float64")+ dist[0] = params[7]+ if self.extra_dist:+ dist[1] = params[8]+ self.set_distortions(dist)++ def distort_points(self, points: np.ndarray) -> np.ndarray:+ shape = points.shape+ points = points.reshape(-1, 1, 2)+ new_points = np.dstack([points, np.ones((points.shape[0], 1, 1))])+ out, _ = cv2.projectPoints(+ new_points, np.zeros(3), np.zeros(3),+ self.matrix.astype("float64"), self.dist.astype("float64"),+ )+ return out.reshape(shape)++ def undistort_points(self, points: np.ndarray) -> np.ndarray:+ shape = points.shape+ points = points.reshape(-1, 1, 2)+ out = cv2.undistortPoints(points, self.matrix.astype("float64"), self.dist.astype("float64"))+ return out.reshape(shape)++ def project(self, points: np.ndarray) -> np.ndarray:+ points = points.reshape(-1, 1, 3)+ out, _ = cv2.projectPoints(+ points, self.rvec, self.tvec,+ self.matrix.astype("float64"), self.dist.astype("float64"),+ )+ return out++ def single_camera_reprojection_error(self, p3d: np.ndarray, p2d: np.ndarray) -> np.ndarray:+ projected = self.project(p3d).reshape(p2d.shape)+ return p2d - projected++ def copy(self) -> "AniposeCamera":+ return AniposeCamera(+ matrix=self.get_camera_matrix().copy(),+ dist=self.get_distortions().copy(),+ size=self.get_size(),+ rvec=self.get_rotation().copy(),+ tvec=self.get_translation().copy(),+ name=self.get_name(),+ extra_dist=self.extra_dist,+ world_orientation=self.get_world_orientation().copy(),+ world_position=self.get_world_position().copy(),+ )+++# =============================================================================+# CAMERA GROUP+# =============================================================================+++class AniposeCameraGroup:+ def __init__(self, cameras: list[AniposeCamera], metadata: dict | None = None):+ self.cameras = cameras+ self.metadata = metadata if metadata is not None else {}++ def subset_cameras(self, indices: list[int]) -> "AniposeCameraGroup":+ cams = [self.cameras[ix].copy() for ix in indices]+ return AniposeCameraGroup(cams, self.metadata)++ def subset_cameras_names(self, names: list[str]) -> "AniposeCameraGroup":+ cur_names = self.get_names()+ cur_names_dict = dict(zip(cur_names, range(len(cur_names))))+ indices = []+ for name in names:+ if name not in cur_names_dict:+ raise IndexError(f"name {name} not part of camera names: {cur_names}")+ indices.append(cur_names_dict[name])+ return self.subset_cameras(indices)++ def project(self, points: np.ndarray) -> np.ndarray:+ """Given Nx3 points, returns CxNx2 projected 2D points."""+ points = points.reshape(-1, 1, 3)+ n_points = points.shape[0]+ n_cams = len(self.cameras)++ out = np.empty((n_cams, n_points, 2), dtype="float64")+ for cnum, cam in enumerate(self.cameras):+ out[cnum] = cam.project(points).reshape(n_points, 2)+ return out++ def triangulate(+ self,+ points: np.ndarray,+ undistort: bool = True,+ progress: bool = False,+ kill_event: Optional[multiprocessing.Event ] = None,+ ) -> np.ndarray | None:+ """Given CxNx2 points, returns Nx3 triangulated 3D points."""+ assert points.shape[0] == len(self.cameras), (+ f"First dim should equal number of cameras ({len(self.cameras)}), "+ f"but shape is {points.shape}"+ )++ one_point = False+ if len(points.shape) == 2:+ points = points.reshape(-1, 1, 2)+ one_point = True++ if undistort:+ new_points = np.empty(points.shape)+ for cnum, cam in enumerate(self.cameras):+ sub = np.copy(points[cnum])+ new_points[cnum] = cam.undistort_points(sub)+ points = new_points++ n_cams, n_points, _ = points.shape+ out = np.empty((n_points, 3))+ out[:] = np.nan++ cam_mats = np.array([cam.get_extrinsics_mat() for cam in self.cameras])+ iterator = trange(n_points, ncols=70) if progress else range(n_points)++ for ip in iterator:+ subp = points[:, ip, :]+ good = ~np.isnan(subp[:, 0])+ if np.sum(good) >= 2:+ out[ip] = triangulate_simple(subp[good], cam_mats[good])+ if kill_event is not None and kill_event.is_set():+ return None++ if one_point:+ out = out[0]+ return out++ @jit(parallel=True, forceobj=True)+ def reprojection_error(self, points_3d: np.ndarray, points_2d: np.ndarray, mean: bool = False):+ """Compute reprojection error. Returns CxNx2, or Nx1 if mean=True."""+ one_point = False+ if len(points_3d.shape) == 1 and len(points_2d.shape) == 2:+ points_3d = points_3d.reshape(1, 3)+ points_2d = points_2d.reshape(-1, 1, 2)+ one_point = True++ n_cams, n_points, _ = points_2d.shape+ assert points_3d.shape == (n_points, 3), (+ f"2D/3D shape mismatch: 2D={points_2d.shape}, 3D={points_3d.shape}"+ )++ errors = np.empty((n_cams, n_points, 2))+ for camera_number, cam in enumerate(self.cameras):+ errors[camera_number] = cam.single_camera_reprojection_error(points_3d, points_2d[camera_number])++ if mean:+ errors_norm = np.linalg.norm(errors, axis=2)+ good = ~np.isnan(errors_norm)+ errors_norm[~good] = 0+ denom = np.sum(good, axis=0).astype("float64")+ denom[denom < 1.5] = np.nan+ errors = np.sum(errors_norm, axis=0) / denom++ if one_point:+ errors = float(errors[0]) if mean else errors.reshape(-1, 2)+ return errors++ # -----------------------------------------------------------------+ # BUNDLE ADJUSTMENT+ # -----------------------------------------------------------------++ def bundle_adjust_iter(+ self,+ p2ds,+ extra=None,+ n_iters=10,+ start_mu=15,+ end_mu=1,+ max_nfev=200,+ ftol=1e-4,+ n_samp_iter=100,+ n_samp_full=1000,+ error_threshold=0.3,+ verbose=False,+ ) -> float:+ """Iterative bundle adjustment with outlier-reducing weight schedule."""+ error_list = []++ assert p2ds.shape[0] == len(self.cameras), (+ f"First dim should equal number of cameras ({len(self.cameras)}), but shape is {p2ds.shape}"+ )++ p2ds_full = p2ds+ extra_full = extra++ p2ds, extra = resample_points(p2ds_full, extra_full, n_samp=n_samp_full)+ error = self.average_error(p2ds, median=True)++ if verbose:+ print("error: ", error)++ mus = np.exp(np.linspace(np.log(start_mu), np.log(end_mu), num=n_iters))++ for i in range(n_iters):+ p2ds, extra = resample_points(p2ds_full, extra_full, n_samp=n_samp_full)+ p3ds = self.triangulate(p2ds)+ errors_full = self.reprojection_error(p3ds, p2ds, mean=False)+ errors_norm = self.reprojection_error(p3ds, p2ds, mean=True)++ error_dict = get_error_dict(errors_full)+ max_error = 0+ min_error = 0+ for k, v in error_dict.items():+ num, percents = v+ max_error = max(percents[-1], max_error)+ min_error = max(percents[0], min_error)+ mu = max(min(max_error, mus[i]), min_error)++ good = errors_norm < mu+ extra_good = subset_extra(extra, good)+ p2ds_samp, extra_samp = resample_points(p2ds[:, good], extra_good, n_samp=n_samp_iter)++ error = np.median(errors_norm)+ error_list.append(error)++ if error < error_threshold:+ break++ if verbose:+ print(error_dict)+ print("error: {:.2f}, mu: {:.1f}, ratio: {:.3f}".format(error, mu, np.mean(good)))++ self.bundle_adjust(+ p2ds_samp, extra_samp, loss="linear", ftol=ftol, max_nfev=max_nfev, verbose=verbose,+ )++ # Final pass with relaxed threshold+ p2ds, extra = resample_points(p2ds_full, extra_full, n_samp=n_samp_full)+ p3ds = self.triangulate(p2ds)+ errors_full = self.reprojection_error(p3ds, p2ds, mean=False)+ errors_norm = self.reprojection_error(p3ds, p2ds, mean=True)+ error_dict = get_error_dict(errors_full)++ max_error = 0+ min_error = 0+ for k, v in error_dict.items():+ num, percents = v+ max_error = max(percents[-1], max_error)+ min_error = max(percents[0], min_error)+ mu = max(max(max_error, end_mu), min_error)++ good = errors_norm < mu+ extra_good = subset_extra(extra, good)+ self.bundle_adjust(+ p2ds[:, good], extra_good, loss="linear", ftol=ftol,+ max_nfev=max(200, max_nfev), verbose=verbose,+ )++ return self.average_error(p2ds, median=True)++ def bundle_adjust(+ self,+ p2ds,+ extra=None,+ loss="linear",+ threshold=50,+ ftol=1e-4,+ max_nfev=1000,+ weights=None,+ start_params=None,+ verbose=True,+ ) -> float:+ """Fine-tune camera parameters via scipy least_squares bundle adjustment."""+ assert p2ds.shape[0] == len(self.cameras), (+ f"First dim should equal number of cameras ({len(self.cameras)}), but shape is {p2ds.shape}"+ )++ if extra is not None:+ extra["ids_map"] = remap_ids(extra["ids"])++ x0, n_cam_params = self._initialize_params_bundle(p2ds, extra)++ if start_params is not None:+ x0 = start_params+ n_cam_params = len(self.cameras[0].get_params())++ jac_sparse = self._jac_sparsity_bundle(p2ds, n_cam_params, extra)++ opt = optimize.least_squares(+ self._error_fun_bundle,+ x0,+ jac_sparsity=jac_sparse,+ f_scale=threshold,+ x_scale="jac",+ loss=loss,+ ftol=ftol,+ method="trf",+ tr_solver="lsmr",+ verbose=2 * verbose,+ max_nfev=max_nfev,+ args=(p2ds, n_cam_params, extra),+ )++ for i, cam in enumerate(self.cameras):+ a = i * n_cam_params+ b = (i + 1) * n_cam_params+ cam.set_params(opt.x[a:b])++ return self.average_error(p2ds)++ @jit(parallel=True, forceobj=True)+ def _error_fun_bundle(self, params, p2ds, n_cam_params, extra):+ """Error function for bundle adjustment."""+ good = ~np.isnan(p2ds)+ n_cams = len(self.cameras)++ for i in range(n_cams):+ a = i * n_cam_params+ b = (i + 1) * n_cam_params+ self.cameras[i].set_params(params[a:b])++ sub = n_cam_params * n_cams+ n3d = p2ds.shape[1] * 3+ p3ds_test = params[sub: sub + n3d].reshape(-1, 3)+ errors_reproj = self.reprojection_error(p3ds_test, p2ds)[good]++ if extra is not None:+ ids = extra["ids_map"]+ objp = extra["objp"]+ min_scale = np.min(objp[objp > 0])+ n_boards = int(np.max(ids)) + 1+ a = sub + n3d+ rvecs = params[a: a + n_boards * 3].reshape(-1, 3)+ tvecs = params[a + n_boards * 3: a + n_boards * 6].reshape(-1, 3)+ expected = transform_points(objp, rvecs[ids], tvecs[ids])+ errors_obj = 2 * (p3ds_test - expected).ravel() / min_scale+ else:+ errors_obj = np.array([])++ return np.hstack([errors_reproj, errors_obj])++ def _jac_sparsity_bundle(self, p2ds, n_cam_params, extra):+ """Compute the sparsity structure of the Jacobian for bundle adjustment."""+ point_indices = np.zeros(p2ds.shape, dtype="int32")+ cam_indices = np.zeros(p2ds.shape, dtype="int32")++ for i in range(p2ds.shape[1]):+ point_indices[:, i] = i+ for j in range(p2ds.shape[0]):+ cam_indices[j] = j++ good = ~np.isnan(p2ds)++ if extra is not None:+ ids = extra["ids_map"]+ n_boards = int(np.max(ids)) + 1+ total_board_params = n_boards * 6+ else:+ n_boards = 0+ total_board_params = 0++ n_cams = p2ds.shape[0]+ n_points = p2ds.shape[1]+ total_params_reproj = n_cams * n_cam_params + n_points * 3+ n_params = total_params_reproj + total_board_params++ n_good_values = np.sum(good)+ n_errors = n_good_values + (n_points * 3 if extra is not None else 0)++ A_sparse = dok_matrix((n_errors, n_params), dtype="int16")++ cam_indices_good = cam_indices[good]+ point_indices_good = point_indices[good]+ ix = np.arange(n_good_values)++ for i in range(n_cam_params):+ A_sparse[ix, cam_indices_good * n_cam_params + i] = 1+ for i in range(3):+ A_sparse[ix, n_cams * n_cam_params + point_indices_good * 3 + i] = 1++ if extra is not None:+ point_ix = np.arange(n_points)+ for i in range(3):+ for j in range(3):+ A_sparse[n_good_values + point_ix * 3 + i, total_params_reproj + ids * 3 + j] = 1+ A_sparse[n_good_values + point_ix * 3 + i, total_params_reproj + n_boards * 3 + ids * 3 + j] = 1+ for i in range(3):+ A_sparse[n_good_values + point_ix * 3 + i, n_cams * n_cam_params + point_ix * 3 + i] = 1++ return A_sparse++ def _initialize_params_bundle(self, p2ds, extra):+ """Initialize parameter vector for bundle adjustment."""+ cam_params = np.hstack([cam.get_params() for cam in self.cameras])+ n_cam_params = len(cam_params) // len(self.cameras)+ total_cam_params = len(cam_params)++ n_cams, n_points, _ = p2ds.shape+ assert n_cams == len(self.cameras), "Camera count mismatch between group and 2D points"++ p3ds = self.triangulate(p2ds)++ if extra is not None:+ ids = extra["ids_map"]+ n_boards = int(np.max(ids[~np.isnan(ids)])) + 1+ total_board_params = n_boards * 6++ rvecs = np.zeros((n_boards, 3), dtype="float64")+ tvecs = np.zeros((n_boards, 3), dtype="float64")++ if "rvecs" in extra and "tvecs" in extra:+ rvecs_all = extra["rvecs"]+ tvecs_all = extra["tvecs"]+ for board_num in range(n_boards):+ point_id = np.where(ids == board_num)[0][0]+ cam_ids_possible = np.where(~np.isnan(p2ds[:, point_id, 0]))[0]+ cam_id = np.random.choice(cam_ids_possible)+ M_cam = self.cameras[cam_id].get_extrinsics_mat()+ M_board_cam = make_M(rvecs_all[cam_id, point_id], tvecs_all[cam_id, point_id])+ M_board = np.linalg.inv(M_cam) @ M_board_cam+ rvec, tvec = get_rtvec(M_board)+ rvecs[board_num] = rvec+ tvecs[board_num] = tvec+ else:+ total_board_params = 0++ x0 = np.zeros(total_cam_params + p3ds.size + total_board_params)+ x0[:total_cam_params] = cam_params+ x0[total_cam_params: total_cam_params + p3ds.size] = p3ds.ravel()++ if extra is not None:+ start_board = total_cam_params + p3ds.size+ x0[start_board: start_board + n_boards * 3] = rvecs.ravel()+ x0[start_board + n_boards * 3: start_board + n_boards * 6] = tvecs.ravel()++ return x0, n_cam_params++ # -----------------------------------------------------------------+ # ACCESSORS & SERIALIZATION+ # -----------------------------------------------------------------++ def average_error(self, p2ds: np.ndarray, median: bool = False) -> float:+ p3ds = self.triangulate(p2ds)+ errors = self.reprojection_error(p3ds, p2ds, mean=True)+ return np.median(errors) if median else np.mean(errors)++ def set_rotations(self, rvecs: np.ndarray) -> None:+ for cam, rvec in zip(self.cameras, rvecs):+ cam.set_rotation(rvec)++ def set_translations(self, tvecs: np.ndarray) -> None:+ for cam, tvec in zip(self.cameras, tvecs):+ cam.set_translation(tvec)++ def set_world_positions(self, positions: list) -> None:+ for cam, position in zip(self.cameras, positions):+ cam.set_world_position(position)++ def set_world_orientations(self, orientations: list) -> None:+ for cam, orientation in zip(self.cameras, orientations):+ cam.set_world_orientation(orientation)++ def get_world_positions(self) -> np.ndarray:+ return np.stack([cam.get_world_position() for cam in self.cameras])++ def get_world_orientations(self) -> np.ndarray:+ return np.stack([cam.get_world_orientation() for cam in self.cameras])++ def get_rotations(self) -> np.ndarray:+ return np.array([cam.get_rotation() for cam in self.cameras])++ def get_translations(self) -> np.ndarray:+ return np.array([cam.get_translation() for cam in self.cameras])++ def get_names(self) -> list[str]:+ return [cam.get_name() for cam in self.cameras]++ def set_names(self, names: list[str]) -> None:+ for cam, name in zip(self.cameras, names):+ cam.set_name(name)++ def copy(self) -> "AniposeCameraGroup":+ cameras = [cam.copy() for cam in self.cameras]+ metadata = copy(self.metadata)+ return AniposeCameraGroup(cameras, metadata)++ def get_dicts(self) -> list[dict]:+ return [cam.get_dict() for cam in self.cameras]++ @staticmethod+ def from_dicts(cameras_dicts: list[dict]) -> "AniposeCameraGroup":+ cameras = [AniposeCamera.from_dict(d) for d in cameras_dicts]+ return AniposeCameraGroup(cameras)++ @staticmethod+ def from_names(names: list[str]) -> "AniposeCameraGroup":+ cameras = [AniposeCamera(name=name) for name in names]+ return AniposeCameraGroup(cameras)++ def load_dicts(self, arr: list[dict]) -> None:+ for cam, d in zip(self.cameras, arr):+ cam.load_dict(d)++ def dump(self, fname: str | Path) -> None:+ dicts = self.get_dicts()+ names = [camera_dict["name"] for camera_dict in dicts]+ master_dict = dict(zip(names, dicts))+ master_dict["metadata"] = self.metadata+ with open(fname, "w") as f:+ toml.dump(master_dict, f)++ @staticmethod+ def load(fname: str | Path) -> "AniposeCameraGroup":+ if not Path(fname).is_file():+ raise FileNotFoundError(f"File {fname} not found.")+ master_dict = toml.load(fname)+ keys = sorted(master_dict.keys())+ items = [master_dict[k] for k in keys if k != "metadata"]+ cgroup = AniposeCameraGroup.from_dicts(items)+ if "metadata" in master_dict:+ cgroup.metadata = master_dict["metadata"]+ return cgroup++ # -----------------------------------------------------------------+ # CALIBRATION+ # -----------------------------------------------------------------++ def calibrate_rows(+ self,+ all_rows: list[list[dict]],+ board,+ init_intrinsics: bool = True,+ init_extrinsics: bool = True,+ verbose: bool = True,+ ) -> tuple[float, list, list]:+ """Calibrate cameras from charuco board observation rows.++ Returns:+ Tuple of (reprojection_error, merged_rows, charuco_frame_numbers).+ """+ n_cameras = len(self.cameras)+ assert len(all_rows) == n_cameras, (+ f"Detection count ({len(all_rows)}) != camera count ({n_cameras})"+ )++ logger.info(f"Calibrating {n_cameras} cameras")+ for cam_idx, (rows, camera) in enumerate(zip(all_rows, self.cameras)):+ logger.info(f"Camera {cam_idx} ({camera.get_name()}): {len(rows)} frames with detections")+ assert camera.get_size() is not None, f"Camera '{camera.get_name()}' has no frame size"++ if init_intrinsics:+ logger.info("Initializing camera intrinsics...")+ for cam_idx, (rows, camera) in enumerate(zip(all_rows, self.cameras)):+ objp, imgp = board.get_all_calibration_points(rows)+ mixed = [(o, i) for (o, i) in zip(objp, imgp) if len(o) >= 7]+ if len(mixed) == 0:+ raise ValueError(f"No valid calibration points for camera {cam_idx} (need >= 7)")+ logger.info(f" Camera {cam_idx}: {len(mixed)} usable frames")+ objp, imgp = zip(*mixed)+ matrix = cv2.initCameraMatrix2D(objp, imgp, tuple(camera.get_size()))+ camera.set_camera_matrix(matrix)++ logger.info("Estimating board poses...")+ for i, (row, cam) in enumerate(zip(all_rows, self.cameras)):+ all_rows[i] = board.estimate_pose_rows(cam, row)++ charuco_frames = [f["framenum"][1] for f in all_rows[0]]++ logger.info("Merging observations across cameras...")+ merged = merge_rows(all_rows)++ imgp, extra = extract_points(merged, board, min_cameras=2)+ logger.info(f"Extracted points: shape={imgp.shape}")++ if init_extrinsics:+ logger.info("Initializing camera extrinsics...")+ rtvecs = extract_rtvecs(merged)++ if verbose:+ connections = get_connections(rtvecs, self.get_names())+ for (cam_a, cam_b), count in sorted(connections.items()):+ if cam_a < cam_b:+ logger.info(f" {cam_a} <-> {cam_b}: {count} shared frames")++ rvecs, tvecs = get_initial_extrinsics(rtvecs, cam_names=self.get_names())+ self.set_rotations(rvecs)+ self.set_translations(tvecs)++ logger.info("Starting iterative bundle adjustment...")+ error = self.bundle_adjust_iter(imgp, extra, verbose=verbose, error_threshold=1)+ logger.info(f"Calibration complete — final error: {error:.4f}")++ return error, merged, charuco_frames+++# =============================================================================+# CHARUCO BOARD+# =============================================================================+++class AniposeCharucoBoard(CharucoBoard):+ def __init__(+ self,+ squaresX: int = 5,+ squaresY: int = 7,+ square_length: float = 1.0,+ marker_length: float = 0.8,+ marker_bits: int = 4,+ dict_size: int = 250,+ ):+ super().__init__(squaresX, squaresY, square_length, marker_length, marker_bits, dict_size)+ self.squaresX = squaresX+ self.squaresY = squaresY+ self.square_length = square_length+ self.marker_length = marker_length+ self.marker_bits = marker_bits+ self.dict_size = dict_size++ dkey = (marker_bits, dict_size)+ self.dictionary = cv2.aruco.getPredefinedDictionary(ARUCO_DICTS[dkey])++ self.board = cv2.aruco.CharucoBoard(+ size=[squaresX, squaresY],+ squareLength=square_length,+ markerLength=marker_length,+ dictionary=self.dictionary,+ )++ total_size = (squaresX - 1) * (squaresY - 1)+ objp = np.zeros((total_size, 3), np.float64)+ objp[:, :2] = np.mgrid[0: (squaresX - 1), 0: (squaresY - 1)].T.reshape(-1, 2)+ objp *= square_length+ self.objPoints = objp+ self.empty_detection = np.zeros((total_size, 1, 2)) * np.nan+ self.total_size = total_size++ def detect_markers(self, image: np.ndarray, camera=None, refine: bool = True):+ gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) if len(image.shape) == 3 else image++ params = cv2.aruco.DetectorParameters()+ params.cornerRefinementMethod = cv2.aruco.CORNER_REFINE_CONTOUR+ params.adaptiveThreshWinSizeMin = 100+ params.adaptiveThreshWinSizeMax = 700+ params.adaptiveThreshWinSizeStep = 50+ params.adaptiveThreshConstant = 0++ try:+ corners, ids, rejectedImgPoints = cv2.aruco.detectMarkers(gray, self.dictionary, parameters=params)+ except Exception:+ ids = None++ if ids is None:+ return [], []++ K = D = None+ if camera is not None:+ K = camera.get_camera_matrix()+ D = camera.get_distortions()++ if refine:+ detectedCorners, detectedIds, _, _ = cv2.aruco.refineDetectedMarkers(+ gray, self.board, corners, ids, rejectedImgPoints, K, D, parameters=params+ )+ else:+ detectedCorners, detectedIds = corners, ids++ return detectedCorners, detectedIds++ def detect_image(self, image: np.ndarray, camera=None):+ gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) if len(image.shape) == 3 else image++ corners, ids = self.detect_markers(image, camera, refine=True)+ if len(corners) > 0:+ ret, detectedCorners, detectedIds = cv2.aruco.interpolateCornersCharuco(+ corners, ids, gray, self.board+ )+ if detectedIds is None:+ detectedCorners = detectedIds = np.float64([])+ else:+ detectedCorners = detectedIds = np.float64([])++ return detectedCorners, detectedIds++ def estimate_pose_points(+ self,+ camera: AniposeCamera,+ corners: np.ndarray | None,+ ids: np.ndarray | None,+ ) -> tuple[np.ndarray | None, np.ndarray | None]:+ if corners is None or ids is None or len(corners) < 5:+ return None, None++ n_corners = corners.size // 2+ corners = np.reshape(corners, (n_corners, 1, 2)).astype(np.float32)+ ids = ids.astype(np.int32) if ids.dtype != np.int32 else ids++ K = camera.get_camera_matrix()+ D = camera.get_distortions()+ ret, rvec, tvec = cv2.aruco.estimatePoseCharucoBoard(corners, ids, self.board, K, D, None, None)+ return rvec, tvecdiff --git a/freemocap/core/calibration/anipose_calibration/run_anipose_calibration.py b/freemocap/core/calibration/anipose_calibration/run_anipose_calibration.pynew file mode 100644index 00000000..70518a7a--- /dev/null+++ b/freemocap/core/calibration/anipose_calibration/run_anipose_calibration.py@@ -0,0 +1,145 @@+"""Run anipose-based camera calibration (legacy solver).++Accepts the shared CharucoBoardDefinition and returns a CalibrationResult,+so both solver paths produce the same output type.+"""++import logging+import time+from pathlib import Path++from skellycam.core.recorders.videos.recording_info import RecordingInfo+from skellycam.core.types.type_overloads import CameraIdString+from skellytracker.trackers.base_tracker.base_tracker_abcs import BaseRecorder+from skellytracker.trackers.charuco_tracker.charuco_observation import CharucoObservation++from freemocap.core.calibration.anipose_calibration.anipose_adapters import create_anipose_board, \+ anipose_group_to_camera_models+from freemocap.core.calibration.anipose_calibration.helpers.calibration_helpers import anipose_pin_camera_zero_to_origin, \+ set_charuco_board_as_groundplane, get_real_world_matrices+from freemocap.core.calibration.anipose_calibration.helpers.freemocap_anipose import AniposeCamera, AniposeCameraGroup+from freemocap.core.calibration.shared.calibration_models import CharucoBoardDefinition, CalibrationResult+from freemocap.core.calibration.shared.charuco_observation_aggregator import CharucoObservationAggregator+from freemocap.core.pipeline.pipeline_configs import CalibrationPipelineConfig+from freemocap.core.pipeline.posthoc.video_group_helper import VideoMetadata+from freemocap.core.types.type_overloads import VideoIdString++logger = logging.getLogger(__name__)+++def run_anipose_calibration(+ *,+ charuco_observations_by_frame: list[dict[CameraIdString, CharucoObservation]],+ board: CharucoBoardDefinition,+ calibration_pipeline_config: CalibrationPipelineConfig,+ video_metadata: dict[VideoIdString, VideoMetadata],+ recording_info: RecordingInfo,+ pin_camera_0_to_origin: bool = True,+ use_charuco_as_groundplane: bool = False,+ init_intrinsics: bool = True,+ init_extrinsics: bool = True,+ verbose: bool = True,+) -> CalibrationResult:+ """Run anipose calibration from charuco observations.++ Returns a CalibrationResult with optimized camera models.+ """+ t_start = time.monotonic()++ anipose_cameras: list[AniposeCamera] = [+ AniposeCamera(+ name=video_id,+ size=(video_meta.width, video_meta.height),+ )+ for video_id, video_meta in video_metadata.items()+ ]+ anipose_camera_group = AniposeCameraGroup(cameras=anipose_cameras)+ anipose_charuco_board = create_anipose_board(board=board)++ logger.info(+ f"Starting Anipose calibration with "+ f"{len(charuco_observations_by_frame)} frames of charuco observations"+ )++ # Aggregate all observations into anipose row format+ charuco_observation_aggregator: CharucoObservationAggregator | None = None+ for charuco_observations_by_camera in charuco_observations_by_frame:+ if charuco_observation_aggregator is None:+ charuco_observation_aggregator = CharucoObservationAggregator.from_charuco_observation_payload(+ charuco_observations_by_camera=charuco_observations_by_camera,+ anipose_camera_ordering=[camera.name for camera in anipose_camera_group.cameras],+ )+ else:+ charuco_observation_aggregator.add_observations(charuco_observations_by_camera)++ if charuco_observation_aggregator is None:+ raise ValueError("No charuco observations were provided for calibration")++ # Run anipose bundle adjustment+ all_camera_rows = charuco_observation_aggregator.all_camera_rows+ logger.info(f"Aggregated charuco observations for {len(all_camera_rows)} cameras")+ error, merged, charuco_frame_numbers = anipose_camera_group.calibrate_rows(+ all_camera_rows,+ anipose_charuco_board,+ init_intrinsics=init_intrinsics,+ init_extrinsics=init_extrinsics,+ verbose=verbose,+ )++ logger.info(f"Anipose calibration completed — error: {error}")++ # Add metadata+ anipose_camera_group.metadata["groundplane_calibration"] = False+ anipose_camera_group.metadata["recording_info"] = recording_info.model_dump()++ # Pin camera 0 to origin+ if pin_camera_0_to_origin:+ anipose_camera_group = anipose_pin_camera_zero_to_origin(camera_group=anipose_camera_group)+ logger.info("Pinned camera 0 to origin")++ # Ground plane correction+ if use_charuco_as_groundplane:+ observation_recorders_by_video: dict[VideoIdString, BaseRecorder] = {+ video_id: BaseRecorder() for video_id in charuco_observations_by_frame[0].keys()+ }+ for frame_number, charuco_observations_by_camera in enumerate(charuco_observations_by_frame):+ if not all(+ isinstance(output, CharucoObservation) for output in charuco_observations_by_camera.values()+ ):+ raise ValueError(+ f"Non-CharucoObservation found in frame {frame_number} observations"+ )+ for video_id, recorder in observation_recorders_by_video.items():+ recorder.add_observation(observation=charuco_observations_by_camera[video_id])++ anipose_camera_group, groundplane_success = set_charuco_board_as_groundplane(+ observation_recorders=observation_recorders_by_video,+ anipose_camera_group=anipose_camera_group,+ anipose_charuco_board=anipose_charuco_board,+ recording_folder_path=Path(recording_info.full_recording_path),+ )+ if groundplane_success.success:+ anipose_camera_group.metadata["groundplane_calibration"] = True+ logger.info("Successfully set charuco board as groundplane")+ else:+ logger.warning(f"Failed to set groundplane: {groundplane_success.error}")++ # Compute real-world camera positions and orientations+ get_real_world_matrices(camera_group=anipose_camera_group)++ # Convert anipose results to shared CameraModel types+ camera_models = anipose_group_to_camera_models(group=anipose_camera_group)++ elapsed = time.monotonic() - t_start++ return CalibrationResult(+ cameras=camera_models,+ board=board,+ reprojection_error_px=float(error),+ initial_cost=0.0,+ final_cost=float(error),+ n_iterations=0,+ time_seconds=elapsed,+ n_observations_used=len(charuco_frame_numbers) * len(camera_models),+ n_observations_rejected=0,+ )diff --git a/freemocap/core/calibration/calibration_task.py b/freemocap/core/calibration/calibration_task.pynew file mode 100644index 00000000..2ac8266c--- /dev/null+++ b/freemocap/core/calibration/calibration_task.py@@ -0,0 +1,314 @@+"""+run_calibration_task: posthoc calibration processing.++Routes to either the legacy anipose solver or the new pyceres bundle+adjustment solver based on task_config.solver_method.++Both paths use the shared CharucoBoardDefinition for board geometry and+return a CalibrationResult. Saving is handled uniformly here via+CalibrationResult.dump_anipose_toml.++Called by PosthocAggregationNode after all frames are collected.+Pre-bind task_config via functools.partial when creating the pipeline.+"""++import json+import logging+from pathlib import Path++import numpy as np+from skellycam.core.recorders.videos.recording_info import RecordingInfo+from skellytracker.trackers.base_tracker.base_tracker_abcs import BaseRecorder+from skellytracker.trackers.charuco_tracker.charuco_observation import CharucoObservation++from freemocap.core.calibration.anipose_calibration.run_anipose_calibration import run_anipose_calibration+from freemocap.core.calibration.pyceres_calibration.pyceres_calibration_pipeline import run_pyceres_calibration+from freemocap.core.calibration.shared.calibration_models import CharucoBoardDefinition, CharucoCornersObservation, \+ CornerObservation, CalibrationResult+from freemocap.core.calibration.shared.calibration_paths import get_last_successful_calibration_toml_path+from freemocap.core.calibration.shared.calibration_save import save_calibration_copies+from freemocap.core.calibration.shared.toml_mixin import numpy_to_python+from freemocap.core.mocap.mocap_helpers.charuco_model_from_observations import charuco_model_from_observations+from freemocap.core.pipeline.pipeline_configs import CalibrationPipelineConfig, CalibrationSolverMethod+from freemocap.core.pipeline.posthoc.video_group_helper import VideoMetadata+from freemocap.core.types.type_overloads import VideoIdString+from scripts.compare_calibrations import compute_calibration_health++logger = logging.getLogger(__name__)+++# =============================================================================+# SHARED: BOARD DEFINITION FACTORY+# =============================================================================+++def _create_board(task_config: CalibrationPipelineConfig) -> CharucoBoardDefinition:+ """Create the shared charuco board definition from pipeline config.++ Single source of truth — both solver paths use this exact board.+ """+ return CharucoBoardDefinition(+ squares_x=task_config.charuco_board_x_squares,+ squares_y=task_config.charuco_board_y_squares,+ square_length_mm=task_config.charuco_square_length,+ marker_length_mm=task_config.charuco_square_length * 0.8,+ )+++# =============================================================================+# SHARED: OBSERVATION CONVERSION+# =============================================================================+++def _charuco_observation_to_frame_observation(+ *,+ charuco_obs: CharucoObservation,+ camera_name: str,+ frame_index: int,+) -> CharucoCornersObservation:+ """Convert a skellytracker CharucoObservation to a CharucoCornersObservation.++ CharucoObservation.to_2d_array() returns shape (n_corners, 2) with NaN for+ undetected corners. The array index IS the corner ID.+ """+ points_2d = charuco_obs.to_2d_array() # (n_corners, 2)++ corners: list[CornerObservation] = []+ for corner_id in range(points_2d.shape[0]):+ xy = points_2d[corner_id]+ if np.isnan(xy).any():+ continue+ corners.append(+ CornerObservation(+ corner_id=corner_id,+ pixel_xy=xy,+ )+ )++ return CharucoCornersObservation(+ camera_name=camera_name,+ frame_index=frame_index,+ corners=corners,+ )+++def _convert_all_observations(+ *,+ charuco_observations_by_frame: list[dict[VideoIdString, CharucoObservation]],+) -> list[CharucoCornersObservation]:+ """Convert all charuco observations to CharucoCornersObservation models."""+ all_frame_obs: list[CharucoCornersObservation] = []++ for frame_idx, frame_obs_by_camera in enumerate(charuco_observations_by_frame):+ for camera_name, charuco_obs in frame_obs_by_camera.items():+ frame_obs = _charuco_observation_to_frame_observation(+ charuco_obs=charuco_obs,+ camera_name=camera_name,+ frame_index=frame_idx,+ )+ if frame_obs.n_corners > 0:+ all_frame_obs.append(frame_obs)++ return all_frame_obs+++# =============================================================================+# SHARED: SAVE CALIBRATION RESULT+# =============================================================================+++def _save_result(+ *,+ result: CalibrationResult,+ recording_info: RecordingInfo,+ solver_method: str,+) -> Path:+ """Save CalibrationResult to all standard locations via anipose-compatible TOML."""+ metadata = {+ "solver_method": solver_method,+ "recording_info": recording_info.model_dump(),+ }++ recording_toml = save_calibration_copies(+ save_fn=lambda path: result.dump_anipose_toml(path=path, metadata=metadata),+ recording_name=recording_info.recording_name,+ recording_folder_path=recording_info.full_recording_path,+ )++ return recording_toml+++# =============================================================================+# PYCERES CALIBRATION PATH+# =============================================================================+++def _run_pyceres_path(+ *,+ all_observations: list[CharucoCornersObservation],+ board: CharucoBoardDefinition,+ task_config: CalibrationPipelineConfig,+ video_metadata: dict[VideoIdString, VideoMetadata],+) -> CalibrationResult:+ """Run calibration using the pyceres bundle adjustment solver."""+ if len(all_observations) == 0:+ raise ValueError("No valid charuco observations found")++ camera_names = list(video_metadata.keys())+ image_sizes: dict[str, tuple[int, int]] = {+ vid_id: (vm.width, vm.height)+ for vid_id, vm in video_metadata.items()+ }++ result = run_pyceres_calibration(+ board=board,+ all_observations=all_observations,+ image_sizes=image_sizes,+ camera_names=camera_names,+ config=task_config.pyceres_solver_config,+ use_groundplane=task_config.use_groundplane,+ )++ logger.info(+ f"Pyceres calibration complete — "+ f"reprojection error: {result.reprojection_error_px:.4f}px, "+ f"time: {result.time_seconds:.2f}s"+ )+ return result+++# =============================================================================+# ANIPOSE CALIBRATION PATH (legacy)+# =============================================================================+++def _run_anipose_path(+ *,+ charuco_observations_by_frame: list[dict[VideoIdString, CharucoObservation]],+ board: CharucoBoardDefinition,+ task_config: CalibrationPipelineConfig,+ recording_info: RecordingInfo,+ video_metadata: dict[VideoIdString, VideoMetadata],+) -> CalibrationResult:+ """Run calibration using the legacy anipose solver."""+ logger.info("Starting anipose calibration...")++ result = run_anipose_calibration(+ charuco_observations_by_frame=charuco_observations_by_frame,+ board=board,+ calibration_pipeline_config=task_config,+ recording_info=recording_info,+ video_metadata=video_metadata,+ )++ logger.info(+ f"Anipose calibration complete — "+ f"reprojection error: {result.reprojection_error_px:.4f}px"+ )+ return result+++# =============================================================================+# ENTRY POINT+# =============================================================================+++def run_calibration_task(+ *,+ frame_observations: list[dict[VideoIdString, CharucoObservation]],+ recording_info: RecordingInfo,+ video_metadata: dict[VideoIdString, VideoMetadata],+ task_config: CalibrationPipelineConfig,+) -> None:+ """Run posthoc calibration on collected charuco observations.++ Routes to either the anipose or pyceres solver based on+ task_config.solver_method. Both paths produce a CalibrationResult+ that is saved via the same anipose-compatible TOML format.+ """+ video_ids = list(video_metadata.keys())++ # ---- Validate all observations are CharucoObservation ----+ charuco_observations_by_frame: list[dict[VideoIdString, CharucoObservation]] = []+ for frame_idx, frame_obs in enumerate(frame_observations):+ frame_charuco: dict[VideoIdString, CharucoObservation] = {}+ for vid_id, obs in frame_obs.items():+ if not isinstance(obs, CharucoObservation):+ raise TypeError(+ f"Expected CharucoObservation for video {vid_id} frame {frame_idx}, "+ f"got {type(obs).__name__}"+ )+ frame_charuco[vid_id] = obs+ charuco_observations_by_frame.append(frame_charuco)+ views_per_camera = {vid_id: len(charuco_observations_by_frame) for vid_id in video_ids}+ logger.debug(f"Received (video id: charuco observation count): {views_per_camera}")++ # ---- Create shared board definition ----+ board = _create_board(task_config=task_config)++ # ---- Convert to shared observation format (used by pyceres and health check) ----+ all_observations = _convert_all_observations(+ charuco_observations_by_frame=charuco_observations_by_frame,+ )++ # Save observations so comparison tools can run board reconstruction tests+ observations_json_path = Path(recording_info.full_recording_path) / "charuco_observations.json"+ observations_json_path.write_text(+ json.dumps([numpy_to_python(obs.model_dump()) for obs in all_observations], indent=4)+ )+ logger.info(f"Saved {len(all_observations)} charuco observations to {observations_json_path}")++ # ---- Route to solver ----+ logger.info(f"Using calibration solver: {task_config.solver_method.value}")++ match task_config.solver_method:+ case CalibrationSolverMethod.ANIPOSE:+ result = _run_anipose_path(+ charuco_observations_by_frame=charuco_observations_by_frame,+ board=board,+ task_config=task_config,+ recording_info=recording_info,+ video_metadata=video_metadata,+ )+ case CalibrationSolverMethod.PYCERES:+ result = _run_pyceres_path(+ all_observations=all_observations,+ board=board,+ task_config=task_config,+ video_metadata=video_metadata,+ )+ case _:+ raise ValueError(f"Unknown solver method: {task_config.solver_method}")++ # ---- Save calibration result (unified for both paths) ----+ _save_result(+ result=result,+ recording_info=recording_info,+ solver_method=task_config.solver_method.value,+ )++ # ---- Log calibration health (including board reconstruction accuracy) ----+ health = compute_calibration_health(+ result=result,+ label=task_config.solver_method.value,+ all_observations=all_observations,+ )+ logger.info(f"\n{health.summary}")++ # ---- Build charuco board model from observations ----+ observation_recorders_by_video: dict[VideoIdString, BaseRecorder] = {+ vid_id: BaseRecorder() for vid_id in video_ids+ }+ for charuco_obs_by_camera in charuco_observations_by_frame:+ for vid_id, recorder in observation_recorders_by_video.items():+ recorder.add_observation(observation=charuco_obs_by_camera[vid_id])++ charuco_model_from_observations(+ observation_recorders=observation_recorders_by_video,+ calibration_toml_path=get_last_successful_calibration_toml_path(),+ output_data_folder=Path(recording_info.full_recording_path) / "output_data",+ )++ logger.info(+ f"Posthoc calibration complete! Output saved to {recording_info.full_recording_path}"+ )\ No newline at end of filediff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/__init__.py b/freemocap/core/calibration/pyceres_calibration/__init__.pysimilarity index 100%rename from freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/__init__.pyrename to freemocap/core/calibration/pyceres_calibration/__init__.pydiff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/__init__.py b/freemocap/core/calibration/pyceres_calibration/helpers/__init__.pysimilarity index 100%rename from freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/__init__.pyrename to freemocap/core/calibration/pyceres_calibration/helpers/__init__.pydiff --git a/freemocap/core/calibration/pyceres_calibration/helpers/cost_functions.py b/freemocap/core/calibration/pyceres_calibration/helpers/cost_functions.pynew file mode 100644index 00000000..bc12dea8--- /dev/null+++ b/freemocap/core/calibration/pyceres_calibration/helpers/cost_functions.py@@ -0,0 +1,217 @@+"""Pyceres cost functions for camera calibration bundle adjustment.++Each cost function connects parameter blocks (camera extrinsics, intrinsics,+board poses) to observed pixel measurements via the camera projection model.+"""++import numpy as np+import pyceres+from numpy.typing import NDArray+from scipy.spatial.transform import Rotation+++# =============================================================================+# PROJECTION HELPERS+# =============================================================================+++def _quat_wxyz_to_rotation_matrix(quat_wxyz: NDArray[np.float64]) -> NDArray[np.float64]:+ """Convert [w, x, y, z] quaternion to 3x3 rotation matrix."""+ w, x, y, z = quat_wxyz+ return Rotation.from_quat([x, y, z, w]).as_matrix()+++def _project_point(+ *,+ point_camera: NDArray[np.float64],+ intrinsics: NDArray[np.float64],+) -> NDArray[np.float64]:+ """Project a 3D point (in camera frame) to 2D pixel coordinates.++ Uses the OpenCV camera model with radial + tangential distortion.++ Args:+ point_camera: (3,) point in camera coordinates [X, Y, Z]+ intrinsics: (8,) array [fx, fy, cx, cy, k1, k2, p1, p2]++ Returns:+ (2,) projected pixel coordinates [u, v]+ """+ fx, fy, cx, cy, k1, k2, p1, p2 = intrinsics++ X, Y, Z = point_camera+ x = X / Z+ y = Y / Z++ r2 = x * x + y * y+ radial = 1.0 + k1 * r2 + k2 * r2 * r2+ x_dist = x * radial + 2.0 * p1 * x * y + p2 * (r2 + 2.0 * x * x)+ y_dist = y * radial + p1 * (r2 + 2.0 * y * y) + 2.0 * p2 * x * y++ u = fx * x_dist + cx+ v = fy * y_dist + cy++ return np.array([u, v], dtype=np.float64)+++# =============================================================================+# REPROJECTION COST+# =============================================================================+++class CharucoReprojectionCost(pyceres.CostFunction):+ """Reprojection error for a single observed charuco corner.++ Transforms a known board corner through the board pose and camera model,+ and computes the pixel-space residual against the observed 2D detection.++ Pipeline:+ 1. p_world = R_board @ p_board + t_board+ 2. p_cam = R_cam @ p_world + t_cam+ 3. p_2d = project(intrinsics, p_cam)+ 4. residual = weight * (observed_2d - p_2d)++ Parameter blocks:+ [0] cam_quaternion_wxyz (4)+ [1] cam_translation (3)+ [2] cam_intrinsics (8) [fx, fy, cx, cy, k1, k2, p1, p2]+ [3] board_quaternion_wxyz (4)+ [4] board_translation (3)++ Residuals: 2 (pixel x error, pixel y error)+ """++ def __init__(+ self,+ *,+ observed_pixel: NDArray[np.float64],+ board_point_3d: NDArray[np.float64],+ weight: float = 1.0,+ ) -> None:+ super().__init__()+ self.observed_pixel = observed_pixel.copy().astype(np.float64)+ self.board_point_3d = board_point_3d.copy().astype(np.float64)+ self.weight = weight+ self.set_num_residuals(2)+ self.set_parameter_block_sizes([4, 3, 8, 4, 3])++ def Evaluate(+ self,+ parameters: list[NDArray[np.float64]],+ residuals: NDArray[np.float64],+ jacobians: list[NDArray[np.float64]] | None,+ ) -> bool:+ cam_quat = parameters[0]+ cam_trans = parameters[1]+ intrinsics = parameters[2]+ board_quat = parameters[3]+ board_trans = parameters[4]++ # Board-local → world+ R_board = _quat_wxyz_to_rotation_matrix(board_quat)+ p_world = R_board @ self.board_point_3d + board_trans++ # World → camera+ R_cam = _quat_wxyz_to_rotation_matrix(cam_quat)+ p_cam = R_cam @ p_world + cam_trans++ # Camera → pixel+ if p_cam[2] <= 1e-6:+ residuals[:] = 0.0+ if jacobians is not None:+ for j_idx in range(5):+ if jacobians[j_idx] is not None:+ jacobians[j_idx][:] = 0.0+ return True++ projected = _project_point(point_camera=p_cam, intrinsics=intrinsics)+ residuals[:] = self.weight * (self.observed_pixel - projected)++ # Numerical Jacobians+ if jacobians is not None:+ eps = 1e-8+ block_sizes = [4, 3, 8, 4, 3]++ for block_idx in range(5):+ if jacobians[block_idx] is None:+ continue++ block_size = block_sizes[block_idx]+ params_copy = [p.copy() for p in parameters]++ for j in range(block_size):+ params_copy[block_idx] = parameters[block_idx].copy()+ params_copy[block_idx][j] += eps++ # Re-normalize quaternions after perturbation+ if block_idx in (0, 3):+ params_copy[block_idx] /= np.linalg.norm(params_copy[block_idx])++ # Recompute forward pass+ R_b = _quat_wxyz_to_rotation_matrix(params_copy[3])+ pw = R_b @ self.board_point_3d + params_copy[4]+ R_c = _quat_wxyz_to_rotation_matrix(params_copy[0])+ pc = R_c @ pw + params_copy[1]++ if pc[2] <= 1e-6:+ for i in range(2):+ jacobians[block_idx][i * block_size + j] = 0.0+ else:+ proj_plus = _project_point(point_camera=pc, intrinsics=params_copy[2])+ res_plus = self.weight * (self.observed_pixel - proj_plus)+ for i in range(2):+ jacobians[block_idx][i * block_size + j] = (+ (res_plus[i] - residuals[i]) / eps+ )++ return True+++# =============================================================================+# INTRINSICS PRIOR+# =============================================================================+++class IntrinsicsPriorCost(pyceres.CostFunction):+ """Soft prior penalizing intrinsics drift from initial estimates.++ Acts as Gaussian regularization: cost = weight * (current - initial).+ Prevents intrinsic parameters from wandering into physically implausible+ regions when observation data is sparse.++ Parameter blocks:+ [0] cam_intrinsics (8) [fx, fy, cx, cy, k1, k2, p1, p2]++ Residuals: 8 (one per intrinsic parameter)+ """++ def __init__(+ self,+ *,+ initial_intrinsics: NDArray[np.float64],+ weight: float = 0.01,+ ) -> None:+ super().__init__()+ self.initial = initial_intrinsics.copy().astype(np.float64)+ if self.initial.shape != (8,):+ raise ValueError(f"Expected shape (8,), got {self.initial.shape}")+ self.weight = weight+ self.set_num_residuals(8)+ self.set_parameter_block_sizes([8])++ def Evaluate(+ self,+ parameters: list[NDArray[np.float64]],+ residuals: NDArray[np.float64],+ jacobians: list[NDArray[np.float64]] | None,+ ) -> bool:+ residuals[:] = self.weight * (parameters[0] - self.initial)++ if jacobians is not None and jacobians[0] is not None:+ # Jacobian is diagonal: d(residual_i)/d(param_j) = weight * delta_ij+ # Stored in row-major: jacobians[0][i * 8 + j]+ jacobians[0][:] = 0.0+ for i in range(8):+ jacobians[0][i * 8 + i] = self.weight++ return Truediff --git a/freemocap/core/calibration/pyceres_calibration/helpers/initialization.py b/freemocap/core/calibration/pyceres_calibration/helpers/initialization.pynew file mode 100644index 00000000..11c8fb69--- /dev/null+++ b/freemocap/core/calibration/pyceres_calibration/helpers/initialization.py@@ -0,0 +1,433 @@+"""Initialize camera intrinsics and extrinsics from charuco observations.++Intrinsics are initialized per-camera using cv2.calibrateCamera.+Extrinsics are initialized by:+ 1. Estimating per-camera board poses via cv2.solvePnP+ 2. Computing pairwise camera transforms from shared board observations+ 3. Building a maximum spanning tree from shared observation counts+ 4. Chaining transforms along the spanning tree to get all cameras in a common frame+"""++import logging+from collections import defaultdict++import cv2+import numpy as np+from numpy.typing import NDArray+from scipy.linalg import inv as matrix_inverse+from scipy.spatial.transform import Rotation++from freemocap.core.calibration.shared.calibration_models import CharucoCornersObservation, CameraIntrinsics, \+ CharucoBoardDefinition, CameraExtrinsics+from freemocap.core.calibration.shared.transform_math import make_M, robust_average_transforms, \+ build_maximum_spanning_tree, find_spanning_tree_pairs, get_rtvec++logger = logging.getLogger(__name__)+++# =============================================================================+# INTRINSICS INITIALIZATION+# =============================================================================+++def initialize_intrinsics(+ *,+ board: CharucoBoardDefinition,+ observations_by_camera: dict[str, list[CharucoCornersObservation]],+ image_sizes: dict[str, tuple[int, int]],+ min_corners: int = 7,+) -> dict[str, CameraIntrinsics]:+ """Initialize camera intrinsics using cv2.calibrateCamera.++ Args:+ board: Charuco board definition with known 3D corner positions.+ observations_by_camera: Per-camera list of frame observations.+ image_sizes: Per-camera image size as (width, height).+ min_corners: Minimum corners in a frame for it to be used.++ Returns:+ Per-camera CameraIntrinsics models.+ """+ board_corners_3d = board.corner_positions_board_frame+ results: dict[str, CameraIntrinsics] = {}++ for cam_name, observations in observations_by_camera.items():+ if cam_name not in image_sizes:+ raise KeyError(f"No image size for camera '{cam_name}'")++ width, height = image_sizes[cam_name]+ obj_points: list[NDArray[np.float64]] = []+ img_points: list[NDArray[np.float64]] = []++ for obs in observations:+ if obs.n_corners < min_corners:+ continue++ obj_pts = np.array(+ [board_corners_3d[c.corner_id] for c in obs.corners],+ dtype=np.float32,+ )+ img_pts = np.array(+ [c.pixel_xy for c in obs.corners],+ dtype=np.float32,+ ).reshape(-1, 1, 2)++ obj_points.append(obj_pts)+ img_points.append(img_pts)++ if len(obj_points) == 0:+ raise ValueError(+ f"Camera '{cam_name}': no frames with >= {min_corners} corners. "+ f"Had {len(observations)} total frames."+ )++ logger.info(f"Camera '{cam_name}': calibrating intrinsics from {len(obj_points)} frames")++ ret, camera_matrix, dist_coeffs, _, _ = cv2.calibrateCamera(+ obj_points,+ img_points,+ imageSize=(width, height),+ cameraMatrix=None,+ distCoeffs=None,+ flags=cv2.CALIB_FIX_K3 | cv2.CALIB_FIX_K4 | cv2.CALIB_FIX_K5 | cv2.CALIB_FIX_K6,+ )++ if not ret:+ raise RuntimeError(f"Camera '{cam_name}': cv2.calibrateCamera failed")++ dist = dist_coeffs.ravel()+ results[cam_name] = CameraIntrinsics(+ fx=float(camera_matrix[0, 0]),+ fy=float(camera_matrix[1, 1]),+ cx=float(camera_matrix[0, 2]),+ cy=float(camera_matrix[1, 2]),+ k1=float(dist[0]) if len(dist) > 0 else 0.0,+ k2=float(dist[1]) if len(dist) > 1 else 0.0,+ p1=float(dist[2]) if len(dist) > 2 else 0.0,+ p2=float(dist[3]) if len(dist) > 3 else 0.0,+ )++ logger.info(+ f"Camera '{cam_name}': fx={results[cam_name].fx:.1f}, "+ f"fy={results[cam_name].fy:.1f}, "+ f"cx={results[cam_name].cx:.1f}, cy={results[cam_name].cy:.1f}, "+ f"k1={results[cam_name].k1:.4f}, k2={results[cam_name].k2:.4f}"+ )++ return results+++# =============================================================================+# BOARD POSE ESTIMATION+# =============================================================================+++def _estimate_board_poses(+ *,+ board: CharucoBoardDefinition,+ observations: list[CharucoCornersObservation],+ intrinsics: CameraIntrinsics,+ min_corners: int = 6,+) -> dict[int, NDArray[np.float64]]:+ """Estimate board pose (4x4 transform) per frame for a single camera.++ Args:+ board: Board definition.+ observations: Frame observations for one camera.+ intrinsics: Camera intrinsics for this camera.+ min_corners: Minimum corners needed for solvePnP.++ Returns:+ Dict mapping frame_index → 4x4 transformation matrix (board-to-camera).+ """+ board_corners_3d = board.corner_positions_board_frame+ K = intrinsics.to_camera_matrix()+ D = intrinsics.to_dist_coeffs()++ poses: dict[int, NDArray[np.float64]] = {}++ for obs in observations:+ if obs.n_corners < min_corners:+ continue++ obj_pts = np.array(+ [board_corners_3d[c.corner_id] for c in obs.corners],+ dtype=np.float64,+ )+ img_pts = np.array(+ [c.pixel_xy for c in obs.corners],+ dtype=np.float64,+ ).reshape(-1, 1, 2)++ success, rvec, tvec = cv2.solvePnP(+ objectPoints=obj_pts,+ imagePoints=img_pts,+ cameraMatrix=K,+ distCoeffs=D,+ flags=cv2.SOLVEPNP_ITERATIVE,+ )++ if not success:+ continue++ poses[obs.frame_index] = make_M(rvec=rvec.ravel(), tvec=tvec.ravel())++ return poses+++# =============================================================================+# PAIRWISE CAMERA TRANSFORMS+# =============================================================================+++def _compute_pairwise_transform(+ *,+ poses_a: dict[int, NDArray[np.float64]],+ poses_b: dict[int, NDArray[np.float64]],+) -> NDArray[np.float64]:+ """Compute the rigid transform from camera B's frame to camera A's frame.++ For each shared frame: T_A_board @ inv(T_B_board) gives T_A_B.+ Robustly averages across all shared frames.+ """+ shared_frames = set(poses_a.keys()) & set(poses_b.keys())+ if len(shared_frames) == 0:+ raise ValueError("No shared frames between camera pair")++ transforms: list[NDArray[np.float64]] = []+ for frame_idx in sorted(shared_frames):+ M_a = poses_a[frame_idx]+ M_b = poses_b[frame_idx]+ T_a_b = M_a @ matrix_inverse(M_b)+ transforms.append(T_a_b)++ logger.debug(f" {len(transforms)} shared frames for pairwise transform")++ return robust_average_transforms(transforms)+++# =============================================================================+# EXTRINSICS INITIALIZATION+# =============================================================================+++def initialize_extrinsics(+ *,+ board: CharucoBoardDefinition,+ observations_by_camera: dict[str, list[CharucoCornersObservation]],+ intrinsics: dict[str, CameraIntrinsics],+ camera_names: list[str],+) -> dict[str, CameraExtrinsics]:+ """Initialize camera extrinsics by chaining pairwise transforms along a spanning tree.++ Camera 0 is placed at the world origin (identity transform). All other cameras+ are expressed relative to it via a maximum-weight spanning tree of shared+ board observations.++ Args:+ board: Board definition.+ observations_by_camera: Per-camera frame observations.+ intrinsics: Per-camera intrinsics (already initialized).+ camera_names: Ordered camera names. Camera 0 becomes the origin.++ Returns:+ Per-camera CameraExtrinsics models.+ """+ n_cams = len(camera_names)+ logger.info(f"Initializing extrinsics for {n_cams} cameras")++ # Step 1: Estimate board poses per camera per frame+ all_board_poses: dict[str, dict[int, NDArray[np.float64]]] = {}+ for cam_name in camera_names:+ if cam_name not in observations_by_camera:+ raise KeyError(f"No observations for camera '{cam_name}'")+ if cam_name not in intrinsics:+ raise KeyError(f"No intrinsics for camera '{cam_name}'")++ poses = _estimate_board_poses(+ board=board,+ observations=observations_by_camera[cam_name],+ intrinsics=intrinsics[cam_name],+ )+ all_board_poses[cam_name] = poses+ logger.info(f"Camera '{cam_name}': estimated board pose in {len(poses)} frames")++ # Step 2: Build spanning tree from shared observation counts+ connections: dict[tuple[int, int], int] = {}+ for i in range(n_cams):+ frames_i = set(all_board_poses[camera_names[i]].keys())+ for j in range(i + 1, n_cams):+ frames_j = set(all_board_poses[camera_names[j]].keys())+ shared = len(frames_i & frames_j)+ if shared > 0:+ connections[(i, j)] = shared+ connections[(j, i)] = shared++ if len(connections) == 0:+ raise ValueError(+ "No shared observations between any camera pair. "+ "Ensure cameras have overlapping views of the charuco board."+ )++ graph = build_maximum_spanning_tree(+ connection_counts=connections,+ n_nodes=n_cams,+ node_labels=camera_names,+ )+ pairs = find_spanning_tree_pairs(graph=graph, root=0)+ logger.info(f"Spanning tree pairs: {[(camera_names[a], camera_names[b]) for a, b in pairs]}")++ # Step 3: Chain pairwise transforms from root+ cam_to_world: dict[int, NDArray[np.float64]] = {0: np.eye(4, dtype=np.float64)}++ for parent_idx, child_idx in pairs:+ parent_name = camera_names[parent_idx]+ child_name = camera_names[child_idx]++ logger.info(f"Computing transform: {child_name} → {parent_name}")++ pairwise = _compute_pairwise_transform(+ poses_a=all_board_poses[child_name],+ poses_b=all_board_poses[parent_name],+ )+ cam_to_world[child_idx] = pairwise @ cam_to_world[parent_idx]++ # Step 4: Convert 4x4 matrices to CameraExtrinsics+ results: dict[str, CameraExtrinsics] = {}+ for cam_idx, cam_name in enumerate(camera_names):+ if cam_idx not in cam_to_world:+ raise RuntimeError(+ f"Camera '{cam_name}' (index {cam_idx}) not reached by spanning tree. "+ f"This indicates a bug in graph construction."+ )++ M = cam_to_world[cam_idx]+ rvec, tvec = get_rtvec(M)++ results[cam_name] = CameraExtrinsics.from_rodrigues(+ rvec=rvec,+ tvec=tvec,+ )+ logger.info(+ f"Camera '{cam_name}': "+ f"translation_norm={np.linalg.norm(tvec):.1f}mm, "+ f"rotation_angle={np.linalg.norm(rvec) * 180 / np.pi:.1f}°"+ )++ return results+++# =============================================================================+# BOARD POSE INITIALIZATION (for solver)+# =============================================================================+++def initialize_board_poses(+ *,+ board: CharucoBoardDefinition,+ observations_by_camera: dict[str, list[CharucoCornersObservation]],+ intrinsics: dict[str, CameraIntrinsics],+ extrinsics: dict[str, CameraExtrinsics],+ all_frame_indices: list[int],+) -> dict[int, tuple[NDArray[np.float64], NDArray[np.float64]]]:+ """Initialize board poses in world frame for each frame.++ Uses the first camera with a valid solvePnP result to estimate the board+ pose in that camera's frame, then transforms it to the world frame.++ Args:+ board: Board definition.+ observations_by_camera: Per-camera frame observations.+ intrinsics: Per-camera intrinsics.+ extrinsics: Per-camera extrinsics.+ all_frame_indices: Sorted list of all frame indices to initialize.++ Returns:+ Dict mapping frame_index → (quaternion_wxyz, translation) in world frame.+ """+ board_corners_3d = board.corner_positions_board_frame+ board_poses: dict[int, tuple[NDArray[np.float64], NDArray[np.float64]]] = {}++ # Build per-frame lookup: frame_index → list of (cam_name, observation)+ frame_lookup: dict[int, list[tuple[str, CharucoCornersObservation]]] = defaultdict(list)+ for cam_name, observations in observations_by_camera.items():+ for obs in observations:+ frame_lookup[obs.frame_index].append((cam_name, obs))++ for frame_idx in all_frame_indices:+ if frame_idx not in frame_lookup:+ # No observations in this frame — use identity as fallback+ board_poses[frame_idx] = (+ np.array([1.0, 0.0, 0.0, 0.0], dtype=np.float64),+ np.zeros(3, dtype=np.float64),+ )+ continue++ # Try each camera until we get a valid PnP result+ found = False+ for cam_name, obs in frame_lookup[frame_idx]:+ if obs.n_corners < 6:+ continue++ K = intrinsics[cam_name].to_camera_matrix()+ D = intrinsics[cam_name].to_dist_coeffs()++ obj_pts = np.array(+ [board_corners_3d[c.corner_id] for c in obs.corners],+ dtype=np.float64,+ )+ img_pts = np.array(+ [c.pixel_xy for c in obs.corners],+ dtype=np.float64,+ ).reshape(-1, 1, 2)++ success, rvec, tvec = cv2.solvePnP(+ objectPoints=obj_pts,+ imagePoints=img_pts,+ cameraMatrix=K,+ distCoeffs=D,+ flags=cv2.SOLVEPNP_ITERATIVE,+ )++ if not success:+ continue++ # Board pose in camera frame+ T_cam_board = make_M(rvec=rvec.ravel(), tvec=tvec.ravel())++ # Camera extrinsics: T_cam_world (world → camera)+ ext = extrinsics[cam_name]+ R_cam_world = ext.rotation_matrix+ t_cam_world = ext.translation+ T_cam_world = np.eye(4, dtype=np.float64)+ T_cam_world[:3, :3] = R_cam_world+ T_cam_world[:3, 3] = t_cam_world++ # Board in world frame: T_world_board = inv(T_cam_world) @ T_cam_board+ T_world_board = matrix_inverse(T_cam_world) @ T_cam_board++ # Extract quaternion (wxyz) and translation+ R_world_board = T_world_board[:3, :3]+ t_world_board = T_world_board[:3, 3]+ quat_xyzw = Rotation.from_matrix(R_world_board).as_quat()+ quat_wxyz = np.array(+ [quat_xyzw[3], quat_xyzw[0], quat_xyzw[1], quat_xyzw[2]],+ dtype=np.float64,+ )++ board_poses[frame_idx] = (quat_wxyz, t_world_board)+ found = True+ break++ if not found:+ board_poses[frame_idx] = (+ np.array([1.0, 0.0, 0.0, 0.0], dtype=np.float64),+ np.zeros(3, dtype=np.float64),+ )++ logger.info(+ f"Initialized board poses for {len(board_poses)} frames "+ f"({sum(1 for q, _ in board_poses.values() if not np.allclose(q, [1, 0, 0, 0]))} with valid PnP)"+ )++ return board_posesdiff --git a/freemocap/core/calibration/pyceres_calibration/helpers/models.py b/freemocap/core/calibration/pyceres_calibration/helpers/models.pynew file mode 100644index 00000000..c1c669df--- /dev/null+++ b/freemocap/core/calibration/pyceres_calibration/helpers/models.py@@ -0,0 +1,79 @@+"""Pyceres-specific data models for camera calibration via bundle adjustment.++Shared types (CharucoBoardDefinition, CameraIntrinsics, CameraExtrinsics,+CameraModel, CornerObservation, CharucoCornersObservation, CalibrationResult)+are imported from shared.models and re-exported here for backward compatibility.+"""++from pydantic import BaseModel, ConfigDict, model_validator++++# =============================================================================+# PYCERES-SPECIFIC: INTRINSICS OPTIMIZATION MODE+# =============================================================================+++class IntrinsicsOptimizationMode(BaseModel):+ """Control which intrinsic parameters are free during optimization."""++ model_config = ConfigDict(extra="forbid", frozen=True)++ optimize_focal_length: bool = True+ shared_focal_length: bool = False+ optimize_principal_point: bool = False+ optimize_k1: bool = False+ optimize_k2: bool = False+ optimize_tangential: bool = False++ @property+ def constant_indices(self) -> list[int]:+ """Indices into the 8-element intrinsics array that should be held constant.++ Array layout: [fx, fy, cx, cy, k1, k2, p1, p2]+ """+ indices: list[int] = []+ if not self.optimize_focal_length:+ indices.extend([0, 1])+ if not self.optimize_principal_point:+ indices.extend([2, 3])+ if not self.optimize_k1:+ indices.append(4)+ if not self.optimize_k2:+ indices.append(5)+ if not self.optimize_tangential:+ indices.extend([6, 7])+ return sorted(indices)+++# =============================================================================+# PYCERES-SPECIFIC: SOLVER CONFIG+# =============================================================================+++class PyceresCalibrationSolverConfig(BaseModel):+ """Configuration for the pyceres bundle adjustment solver."""++ model_config = ConfigDict(extra="forbid", frozen=True)++ max_iterations: int = 100+ function_tolerance: float = 1e-6+ parameter_tolerance: float = 1e-8+ gradient_tolerance: float = 1e-10+ intrinsics_mode: IntrinsicsOptimizationMode = IntrinsicsOptimizationMode()+ intrinsics_prior_weight: float = 0.01+ pin_camera_0: bool = True+ outlier_rejection_iterations: int = 5+ initial_outlier_threshold_px: float = 15.0+ final_outlier_threshold_px: float = 2.0+ min_corners_per_frame: int = 4+ verbose: bool = True++ @model_validator(mode="after")+ def validate_thresholds(self) -> "PyceresCalibrationSolverConfig":+ if self.initial_outlier_threshold_px < self.final_outlier_threshold_px:+ raise ValueError(+ f"initial_outlier_threshold_px ({self.initial_outlier_threshold_px}) "+ f"must be >= final_outlier_threshold_px ({self.final_outlier_threshold_px})"+ )+ return selfdiff --git a/freemocap/core/calibration/pyceres_calibration/helpers/postprocessing.py b/freemocap/core/calibration/pyceres_calibration/helpers/postprocessing.pynew file mode 100644index 00000000..5bc0060d--- /dev/null+++ b/freemocap/core/calibration/pyceres_calibration/helpers/postprocessing.py@@ -0,0 +1,247 @@+"""Post-processing transforms for calibrated cameras.++Pin camera 0 to origin, align charuco board as ground plane,+compute world-frame camera positions and orientations.+"""++import logging++import numpy as np+from numpy.typing import NDArray+from scipy.spatial.transform import Rotation++from freemocap.core.calibration.shared.calibration_models import CameraModel, CameraExtrinsics, \+ CharucoCornersObservation, CharucoBoardDefinition+from freemocap.core.calibration.shared.groundplane_math import find_still_charuco_frame, compute_board_basis_vectors++logger = logging.getLogger(__name__)+++# =============================================================================+# PIN CAMERA TO ORIGIN+# =============================================================================+++def pin_camera_to_origin(+ *,+ cameras: list[CameraModel],+ camera_index: int = 0,+) -> list[CameraModel]:+ """Re-express all camera extrinsics relative to the specified camera.++ After this transform, the target camera has identity rotation and zero+ translation (it sits at the world origin looking along +Z).++ Args:+ cameras: List of camera models with extrinsics.+ camera_index: Index of the camera to place at the origin.++ Returns:+ New list of CameraModel with adjusted extrinsics.+ """+ if camera_index < 0 or camera_index >= len(cameras):+ raise IndexError(+ f"camera_index {camera_index} out of range for {len(cameras)} cameras"+ )++ ref_cam = cameras[camera_index]+ R0 = ref_cam.extrinsics.rotation_matrix+ t0 = ref_cam.extrinsics.translation++ result: list[CameraModel] = []+ for cam in cameras:+ R_i = cam.extrinsics.rotation_matrix+ t_i = cam.extrinsics.translation++ # New rotation: R_i_new = R_i @ R0^T+ R_new = R_i @ R0.T++ # New translation: t_new = t_i + R_i @ R0^T @ (-t0)+ t_new = t_i + R_i @ R0.T @ (-t0)++ # Convert to quaternion wxyz+ quat_xyzw = Rotation.from_matrix(R_new).as_quat()+ quat_wxyz = np.array(+ [quat_xyzw[3], quat_xyzw[0], quat_xyzw[1], quat_xyzw[2]],+ dtype=np.float64,+ )++ new_extrinsics = CameraExtrinsics(+ quaternion_wxyz=quat_wxyz,+ translation=t_new,+ )++ result.append(+ CameraModel(+ name=cam.name,+ image_size=cam.image_size,+ intrinsics=cam.intrinsics,+ extrinsics=new_extrinsics,+ )+ )++ logger.info(+ f"Pinned camera '{cameras[camera_index].name}' to origin. "+ f"Adjusted {len(cameras)} camera extrinsics."+ )++ return result+++# =============================================================================+# GROUND PLANE ALIGNMENT+# =============================================================================+++def _triangulate_charuco_corners(+ *,+ cameras: list[CameraModel],+ all_observations: list[CharucoCornersObservation],+ board: CharucoBoardDefinition,+) -> NDArray[np.float64]:+ """Triangulate charuco corners into 3D for ground plane estimation.++ Uses DLT triangulation across all cameras for each frame, then stacks+ into (n_frames, n_corners, 3). Missing corners are filled with NaN.++ Returns:+ (n_frames, n_corners, 3) array of triangulated 3D positions.+ """+ # Group observations by frame+ cam_name_to_model = {cam.name: cam for cam in cameras}+ frame_groups: dict[int, dict[str, CharucoCornersObservation]] = {}+ for obs in all_observations:+ if obs.frame_index not in frame_groups:+ frame_groups[obs.frame_index] = {}+ frame_groups[obs.frame_index][obs.camera_name] = obs++ sorted_frames = sorted(frame_groups.keys())+ n_frames = len(sorted_frames)+ n_corners = board.n_corners++ result = np.full((n_frames, n_corners, 3), np.nan, dtype=np.float64)++ for fi, frame_idx in enumerate(sorted_frames):+ frame_obs = frame_groups[frame_idx]++ for corner_id in range(n_corners):+ # Collect 2D observations of this corner across cameras+ cam_observations: list[tuple[NDArray[np.float64], NDArray[np.float64]]] = []++ for cam_name, obs in frame_obs.items():+ cam = cam_name_to_model[cam_name]+ for c in obs.corners:+ if c.corner_id == corner_id:+ P = cam.projection_matrix+ cam_observations.append((c.pixel_xy, P))+ break++ if len(cam_observations) < 2:+ continue++ # DLT triangulation+ n_views = len(cam_observations)+ A = np.zeros((n_views * 2, 4), dtype=np.float64)+ for vi, (px, P) in enumerate(cam_observations):+ x, y = px+ A[vi * 2] = x * P[2] - P[0]+ A[vi * 2 + 1] = y * P[2] - P[1]++ _, _, vh = np.linalg.svd(A, full_matrices=False)+ pt_h = vh[-1]+ if abs(pt_h[3]) < 1e-10:+ continue+ result[fi, corner_id] = pt_h[:3] / pt_h[3]++ return result+++def align_to_charuco_groundplane(+ *,+ cameras: list[CameraModel],+ board: CharucoBoardDefinition,+ all_observations: list[CharucoCornersObservation],+) -> list[CameraModel]:+ """Transform the world frame so the charuco board defines the ground plane.++ The charuco board's origin corner becomes the world origin, its X edge+ defines +X, and the board normal defines +Z (up).++ Args:+ cameras: Calibrated camera models.+ board: Board definition.+ all_observations: All frame observations for triangulation.++ Returns:+ Camera models with extrinsics adjusted to the new world frame.+ """+ logger.info("Aligning world frame to charuco ground plane...")++ # Triangulate all charuco corners+ charuco_3d = _triangulate_charuco_corners(+ cameras=cameras,+ all_observations=all_observations,+ board=board,+ )++ # Find a stationary frame+ still_frame_idx = find_still_charuco_frame(+ charuco_3d=charuco_3d,+ squares_x=board.squares_x,+ squares_y=board.squares_y,+ )+ logger.info(f"Using frame {still_frame_idx} for ground plane alignment")++ frame_corners = charuco_3d[still_frame_idx]++ # Validate key corners are visible+ origin = frame_corners[0]+ if np.isnan(origin).any():+ raise RuntimeError(+ "Origin charuco corner contains NaN in the selected frame. "+ "Cannot establish ground plane."+ )++ # Compute orthonormal basis from the board corners+ x_hat, y_hat, z_hat = compute_board_basis_vectors(+ charuco_frame=frame_corners,+ squares_x=board.squares_x,+ squares_y=board.squares_y,+ )++ # Rotation from charuco frame to current world frame+ R_charuco_to_world = np.column_stack([x_hat, y_hat, z_hat])++ # Transform all cameras: new extrinsics map from "charuco world" to camera+ result: list[CameraModel] = []+ for cam in cameras:+ R_cam = cam.extrinsics.rotation_matrix+ t_cam = cam.extrinsics.translation++ # Shift origin, then rotate+ t_delta = R_cam @ origin+ t_new = t_cam + t_delta++ # Compose with charuco-to-world rotation+ R_new = R_cam @ R_charuco_to_world++ quat_xyzw = Rotation.from_matrix(R_new).as_quat()+ quat_wxyz = np.array(+ [quat_xyzw[3], quat_xyzw[0], quat_xyzw[1], quat_xyzw[2]],+ dtype=np.float64,+ )++ result.append(+ CameraModel(+ name=cam.name,+ image_size=cam.image_size,+ intrinsics=cam.intrinsics,+ extrinsics=CameraExtrinsics(+ quaternion_wxyz=quat_wxyz,+ translation=t_new,+ ),+ )+ )++ logger.info("Ground plane alignment complete")+ return resultdiff --git a/freemocap/core/calibration/pyceres_calibration/helpers/solver.py b/freemocap/core/calibration/pyceres_calibration/helpers/solver.pynew file mode 100644index 00000000..c1738313--- /dev/null+++ b/freemocap/core/calibration/pyceres_calibration/helpers/solver.py@@ -0,0 +1,441 @@+"""Bundle adjustment solver for camera calibration using pyceres.++Builds a pyceres optimization problem from camera models, board definition,+and 2D corner observations. Supports iterative outlier rejection.+"""++import logging+import time+from collections import defaultdict++import numpy as np+import pyceres+from numpy.typing import NDArray+from scipy.spatial.transform import Rotation++from freemocap.core.calibration.pyceres_calibration.helpers.cost_functions import CharucoReprojectionCost, \+ IntrinsicsPriorCost+from freemocap.core.calibration.pyceres_calibration.helpers.models import PyceresCalibrationSolverConfig+from freemocap.core.calibration.shared.calibration_models import CharucoBoardDefinition, CameraModel, \+ CharucoCornersObservation, CalibrationResult, CameraIntrinsics, CameraExtrinsics++logger = logging.getLogger(__name__)+++# =============================================================================+# OBSERVATION INDEXING+# =============================================================================+++class _ObservationRecord:+ """Tracks a single 2D observation and which parameter blocks it connects."""++ __slots__ = ("camera_name", "frame_index", "corner_id", "pixel_xy", "is_outlier")++ def __init__(+ self,+ *,+ camera_name: str,+ frame_index: int,+ corner_id: int,+ pixel_xy: NDArray[np.float64],+ ) -> None:+ self.camera_name = camera_name+ self.frame_index = frame_index+ self.corner_id = corner_id+ self.pixel_xy = pixel_xy.copy()+ self.is_outlier = False+++# =============================================================================+# REPROJECTION ERROR COMPUTATION+# =============================================================================+++def _compute_reprojection_errors(+ *,+ observations: list[_ObservationRecord],+ board: CharucoBoardDefinition,+ cam_quats: dict[str, NDArray[np.float64]],+ cam_trans: dict[str, NDArray[np.float64]],+ cam_intrinsics: dict[str, NDArray[np.float64]],+ board_quats: dict[int, NDArray[np.float64]],+ board_trans: dict[int, NDArray[np.float64]],+) -> NDArray[np.float64]:+ """Compute per-observation reprojection errors (in pixels).++ Returns array of shape (n_observations,) with pixel-space L2 error.+ """+ board_pts = board.corner_positions_board_frame+ errors = np.zeros(len(observations), dtype=np.float64)++ for idx, obs in enumerate(observations):+ cq = cam_quats[obs.camera_name]+ ct = cam_trans[obs.camera_name]+ ci = cam_intrinsics[obs.camera_name]+ bq = board_quats[obs.frame_index]+ bt = board_trans[obs.frame_index]++ # Board → world+ w, x, y, z = bq+ R_board = Rotation.from_quat([x, y, z, w]).as_matrix()+ p_world = R_board @ board_pts[obs.corner_id] + bt++ # World → camera+ w, x, y, z = cq+ R_cam = Rotation.from_quat([x, y, z, w]).as_matrix()+ p_cam = R_cam @ p_world + ct++ if p_cam[2] <= 1e-6:+ errors[idx] = 1e6+ continue++ # Project+ fx, fy, cx, cy, k1, k2, p1, p2 = ci+ xn = p_cam[0] / p_cam[2]+ yn = p_cam[1] / p_cam[2]+ r2 = xn * xn + yn * yn+ radial = 1.0 + k1 * r2 + k2 * r2 * r2+ xd = xn * radial + 2.0 * p1 * xn * yn + p2 * (r2 + 2.0 * xn * xn)+ yd = yn * radial + p1 * (r2 + 2.0 * yn * yn) + 2.0 * p2 * xn * yn+ u = fx * xd + cx+ v = fy * yd + cy++ diff = obs.pixel_xy - np.array([u, v])+ errors[idx] = np.linalg.norm(diff)++ return errors+++# =============================================================================+# SOLVER+# =============================================================================+++def run_pyceres_bundle_adjustment(+ *,+ cameras: list[CameraModel],+ board: CharucoBoardDefinition,+ all_observations: list[CharucoCornersObservation],+ board_poses_init: dict[int, tuple[NDArray[np.float64], NDArray[np.float64]]],+ config: PyceresCalibrationSolverConfig,+) -> CalibrationResult:+ """Run iterative bundle adjustment with outlier rejection.++ Args:+ cameras: Initial camera models (intrinsics + extrinsics).+ board: Charuco board definition.+ all_observations: All frame observations across all cameras.+ board_poses_init: Initial board poses {frame_idx: (quat_wxyz, translation)}.+ config: Solver configuration.++ Returns:+ CalibrationResult with optimized camera models.+ """+ t_start = time.monotonic()+ camera_name_to_idx = {cam.name: idx for idx, cam in enumerate(cameras)}+ board_pts_3d = board.corner_positions_board_frame++ # =========================================================================+ # BUILD OBSERVATION RECORDS+ # =========================================================================+ obs_records: list[_ObservationRecord] = []+ frame_indices_set: set[int] = set()++ for frame_obs in all_observations:+ cam_name = frame_obs.camera_name+ if cam_name not in camera_name_to_idx:+ raise ValueError(f"Observation references unknown camera '{cam_name}'")++ if frame_obs.n_corners < config.min_corners_per_frame:+ continue++ for corner in frame_obs.corners:+ if corner.corner_id < 0 or corner.corner_id >= board.n_corners:+ raise ValueError(+ f"Corner ID {corner.corner_id} out of range [0, {board.n_corners})"+ )+ obs_records.append(+ _ObservationRecord(+ camera_name=cam_name,+ frame_index=frame_obs.frame_index,+ corner_id=corner.corner_id,+ pixel_xy=corner.pixel_xy,+ )+ )+ frame_indices_set.add(frame_obs.frame_index)++ if len(obs_records) == 0:+ raise ValueError("No valid observations after filtering")++ sorted_frame_indices = sorted(frame_indices_set)+ frame_idx_to_pos = {fi: pos for pos, fi in enumerate(sorted_frame_indices)}++ logger.info(f"Total observations: {len(obs_records)}")+ logger.info(f"Cameras: {len(cameras)}")+ logger.info(f"Board frames: {len(sorted_frame_indices)}")++ # Per-camera observation counts+ cam_obs_counts: dict[str, int] = defaultdict(int)+ for obs in obs_records:+ cam_obs_counts[obs.camera_name] += 1+ for cam in cameras:+ logger.info(f" Camera '{cam.name}': {cam_obs_counts.get(cam.name, 0)} corner observations")++ # =========================================================================+ # ALLOCATE PARAMETER ARRAYS+ # =========================================================================+ n_cams = len(cameras)+ n_board_frames = len(sorted_frame_indices)++ # Camera parameters (persistent numpy arrays — modified in-place by Ceres)+ cam_quat_arrays: dict[str, NDArray[np.float64]] = {}+ cam_trans_arrays: dict[str, NDArray[np.float64]] = {}+ cam_intrinsics_arrays: dict[str, NDArray[np.float64]] = {}++ for cam in cameras:+ cam_quat_arrays[cam.name] = cam.extrinsics.quaternion_wxyz.copy()+ cam_trans_arrays[cam.name] = cam.extrinsics.translation.copy()+ cam_intrinsics_arrays[cam.name] = cam.intrinsics.to_param_array()++ # Board pose parameters+ board_quat_arrays: dict[int, NDArray[np.float64]] = {}+ board_trans_arrays: dict[int, NDArray[np.float64]] = {}++ for frame_idx in sorted_frame_indices:+ if frame_idx in board_poses_init:+ q, t = board_poses_init[frame_idx]+ board_quat_arrays[frame_idx] = q.copy()+ board_trans_arrays[frame_idx] = t.copy()+ else:+ board_quat_arrays[frame_idx] = np.array([1.0, 0.0, 0.0, 0.0], dtype=np.float64)+ board_trans_arrays[frame_idx] = np.zeros(3, dtype=np.float64)++ # Save initial intrinsics for prior cost+ initial_intrinsics: dict[str, NDArray[np.float64]] = {+ cam.name: cam.intrinsics.to_param_array() for cam in cameras+ }++ # =========================================================================+ # ITERATIVE OUTLIER REJECTION+ # =========================================================================+ n_rejected_total = 0+ initial_cost = 0.0+ final_cost = 0.0+ total_iterations = 0++ n_outlier_iters = config.outlier_rejection_iterations+ thresholds = np.exp(+ np.linspace(+ np.log(config.initial_outlier_threshold_px),+ np.log(config.final_outlier_threshold_px),+ num=n_outlier_iters,+ )+ )++ for outlier_iter in range(n_outlier_iters):+ threshold = float(thresholds[outlier_iter])+ active_obs = [obs for obs in obs_records if not obs.is_outlier]++ if len(active_obs) == 0:+ raise RuntimeError(+ "All observations marked as outliers. "+ "Calibration data may be too noisy or initialization too far off."+ )++ logger.info(+ f"\n{'='*60}\n"+ f"Outlier iteration {outlier_iter + 1}/{n_outlier_iters} | "+ f"threshold={threshold:.2f}px | "+ f"active observations: {len(active_obs)}\n"+ f"{'='*60}"+ )++ # =====================================================================+ # BUILD CERES PROBLEM+ # =====================================================================+ problem = pyceres.Problem()++ # Register camera parameter blocks+ for cam in cameras:+ q_arr = cam_quat_arrays[cam.name]+ t_arr = cam_trans_arrays[cam.name]+ i_arr = cam_intrinsics_arrays[cam.name]++ problem.add_parameter_block(q_arr, 4)+ problem.set_manifold(q_arr, pyceres.QuaternionManifold())+ problem.add_parameter_block(t_arr, 3)+ problem.add_parameter_block(i_arr, 8)++ # Apply intrinsics optimization mode+ constant_indices = config.intrinsics_mode.constant_indices+ if len(constant_indices) == 8:+ problem.set_parameter_block_constant(i_arr)+ elif len(constant_indices) > 0:+ problem.set_manifold(+ i_arr,+ pyceres.SubsetManifold(8, constant_indices),+ )++ # Pin camera 0 extrinsics if configured+ if config.pin_camera_0:+ cam0 = cameras[0]+ problem.set_parameter_block_constant(cam_quat_arrays[cam0.name])+ problem.set_parameter_block_constant(cam_trans_arrays[cam0.name])++ # Register board pose parameter blocks+ for frame_idx in sorted_frame_indices:+ bq = board_quat_arrays[frame_idx]+ bt = board_trans_arrays[frame_idx]+ problem.add_parameter_block(bq, 4)+ problem.set_manifold(bq, pyceres.QuaternionManifold())+ problem.add_parameter_block(bt, 3)++ # Add reprojection cost for each active observation+ n_residuals_added = 0+ for obs in active_obs:+ cost = CharucoReprojectionCost(+ observed_pixel=obs.pixel_xy,+ board_point_3d=board_pts_3d[obs.corner_id],+ weight=1.0,+ )+ problem.add_residual_block(+ cost,+ pyceres.HuberLoss(threshold), # Robust loss+ [+ cam_quat_arrays[obs.camera_name],+ cam_trans_arrays[obs.camera_name],+ cam_intrinsics_arrays[obs.camera_name],+ board_quat_arrays[obs.frame_index],+ board_trans_arrays[obs.frame_index],+ ],+ )+ n_residuals_added += 1++ # Add intrinsics priors+ if config.intrinsics_prior_weight > 0:+ for cam in cameras:+ prior_cost = IntrinsicsPriorCost(+ initial_intrinsics=initial_intrinsics[cam.name],+ weight=config.intrinsics_prior_weight,+ )+ problem.add_residual_block(+ prior_cost,+ None,+ [cam_intrinsics_arrays[cam.name]],+ )++ logger.info(f"Problem: {problem.num_residual_blocks()} residual blocks, "+ f"{problem.num_parameters()} parameters")++ # =====================================================================+ # SOLVE+ # =====================================================================+ options = pyceres.SolverOptions()+ options.linear_solver_type = pyceres.LinearSolverType.SPARSE_SCHUR+ options.max_num_iterations = config.max_iterations+ options.function_tolerance = config.function_tolerance+ options.parameter_tolerance = config.parameter_tolerance+ options.gradient_tolerance = config.gradient_tolerance+ options.minimizer_progress_to_stdout = config.verbose++ summary = pyceres.SolverSummary()+ pyceres.solve(options, problem, summary)++ if outlier_iter == 0:+ initial_cost = summary.initial_cost++ final_cost = summary.final_cost+ total_iterations += summary.num_successful_steps++ logger.info(f"Solver: {summary.termination_type}")+ logger.info(f" Initial cost: {summary.initial_cost:.4f}")+ logger.info(f" Final cost: {summary.final_cost:.4f}")+ logger.info(f" Iterations: {summary.num_successful_steps}")+ logger.info(f" Time: {summary.total_time_in_seconds:.2f}s")++ # =====================================================================+ # MARK OUTLIERS+ # =====================================================================+ if outlier_iter < n_outlier_iters - 1:+ errors = _compute_reprojection_errors(+ observations=obs_records,+ board=board,+ cam_quats=cam_quat_arrays,+ cam_trans=cam_trans_arrays,+ cam_intrinsics=cam_intrinsics_arrays,+ board_quats=board_quat_arrays,+ board_trans=board_trans_arrays,+ )++ n_newly_rejected = 0+ for idx, obs in enumerate(obs_records):+ if not obs.is_outlier and errors[idx] > threshold:+ obs.is_outlier = True+ n_newly_rejected += 1+ n_rejected_total += 1++ active_errors = errors[~np.array([obs.is_outlier for obs in obs_records])]+ if len(active_errors) > 0:+ logger.info(+ f"Reprojection error: "+ f"median={np.median(active_errors):.3f}px, "+ f"mean={np.mean(active_errors):.3f}px, "+ f"max={np.max(active_errors):.3f}px"+ )+ logger.info(f"Rejected {n_newly_rejected} observations this iteration "+ f"(total rejected: {n_rejected_total})")++ # =========================================================================+ # COMPUTE FINAL ERROR+ # =========================================================================+ final_errors = _compute_reprojection_errors(+ observations=[obs for obs in obs_records if not obs.is_outlier],+ board=board,+ cam_quats=cam_quat_arrays,+ cam_trans=cam_trans_arrays,+ cam_intrinsics=cam_intrinsics_arrays,+ board_quats=board_quat_arrays,+ board_trans=board_trans_arrays,+ )++ median_error = float(np.median(final_errors)) if len(final_errors) > 0 else float("inf")+ logger.info(f"\nFinal median reprojection error: {median_error:.4f} px")++ # =========================================================================+ # BUILD RESULT+ # =========================================================================+ result_cameras: list[CameraModel] = []+ for cam in cameras:+ new_intrinsics = CameraIntrinsics.from_param_array(cam_intrinsics_arrays[cam.name])++ quat = cam_quat_arrays[cam.name]+ trans = cam_trans_arrays[cam.name]+ new_extrinsics = CameraExtrinsics(+ quaternion_wxyz=quat.copy(),+ translation=trans.copy(),+ )++ result_cameras.append(+ CameraModel(+ name=cam.name,+ image_size=cam.image_size,+ intrinsics=new_intrinsics,+ extrinsics=new_extrinsics,+ )+ )++ elapsed = time.monotonic() - t_start+ n_used = sum(1 for obs in obs_records if not obs.is_outlier)++ return CalibrationResult(+ cameras=result_cameras,+ board=board,+ reprojection_error_px=median_error,+ initial_cost=initial_cost,+ final_cost=final_cost,+ n_iterations=total_iterations,+ time_seconds=elapsed,+ n_observations_used=n_used,+ n_observations_rejected=n_rejected_total,+ )\ No newline at end of filediff --git a/freemocap/core/calibration/pyceres_calibration/pyceres_calibration_pipeline.py b/freemocap/core/calibration/pyceres_calibration/pyceres_calibration_pipeline.pynew file mode 100644index 00000000..34bccb41--- /dev/null+++ b/freemocap/core/calibration/pyceres_calibration/pyceres_calibration_pipeline.py@@ -0,0 +1,208 @@+"""Top-level pyceres calibration pipeline.++Orchestrates the full calibration flow:+ 1. Validate and organize observations+ 2. Initialize intrinsics (per-camera cv2.calibrateCamera)+ 3. Initialize extrinsics (pairwise transforms → spanning tree)+ 4. Initialize board poses (per-frame solvePnP → world transform)+ 5. Bundle adjustment (pyceres with iterative outlier rejection)+ 6. Post-processing (pin to origin, optional groundplane alignment)+ 7. Save results+"""++import logging++from freemocap.core.calibration.pyceres_calibration.helpers.initialization import initialize_intrinsics, \+ initialize_extrinsics, initialize_board_poses+from freemocap.core.calibration.pyceres_calibration.helpers.models import PyceresCalibrationSolverConfig+from freemocap.core.calibration.pyceres_calibration.helpers.postprocessing import pin_camera_to_origin, \+ align_to_charuco_groundplane+from freemocap.core.calibration.pyceres_calibration.helpers.solver import run_pyceres_bundle_adjustment+from freemocap.core.calibration.shared.calibration_models import CharucoBoardDefinition, CharucoCornersObservation, \+ CalibrationResult, CameraModel++logger = logging.getLogger(__name__)+++def run_pyceres_calibration(+ *,+ board: CharucoBoardDefinition,+ all_observations: list[CharucoCornersObservation],+ image_sizes: dict[str, tuple[int, int]],+ camera_names: list[str],+ config: PyceresCalibrationSolverConfig,+ use_groundplane: bool = False,+) -> CalibrationResult:+ """Run the complete camera calibration pipeline.++ Args:+ board: Charuco board definition.+ all_observations: All FrameObservation records across all cameras and frames.+ image_sizes: Per-camera image size as {name: (width, height)}.+ camera_names: Ordered list of camera names. Camera 0 is the reference.+ config: Solver configuration.+ use_groundplane: If True, align the world frame to the charuco board plane.++ Returns:+ CalibrationResult with optimized cameras. Caller is responsible for saving.+ """+ # =========================================================================+ # VALIDATE INPUTS+ # =========================================================================+ if len(camera_names) < 2:+ raise ValueError(f"Need at least 2 cameras, got {len(camera_names)}")++ if len(all_observations) == 0:+ raise ValueError("No observations provided")++ for cam_name in camera_names:+ if cam_name not in image_sizes:+ raise KeyError(f"No image size for camera '{cam_name}'")++ # Group observations by camera+ observations_by_camera: dict[str, list[CharucoCornersObservation]] = {+ name: [] for name in camera_names+ }+ for obs in all_observations:+ if obs.camera_name not in observations_by_camera:+ raise ValueError(+ f"Observation references unknown camera '{obs.camera_name}'. "+ f"Known cameras: {camera_names}"+ )+ observations_by_camera[obs.camera_name].append(obs)++ for cam_name in camera_names:+ n_obs = len(observations_by_camera[cam_name])+ if n_obs == 0:+ raise ValueError(f"Camera '{cam_name}' has zero observations")+ logger.info(f"Camera '{cam_name}': {n_obs} frame observations")++ # =========================================================================+ # STEP 1: INITIALIZE INTRINSICS+ # =========================================================================+ logger.info("\n" + "=" * 80)+ logger.info("STEP 1: INITIALIZE INTRINSICS")+ logger.info("=" * 80)++ intrinsics = initialize_intrinsics(+ board=board,+ observations_by_camera=observations_by_camera,+ image_sizes=image_sizes,+ )++ # =========================================================================+ # STEP 2: INITIALIZE EXTRINSICS+ # =========================================================================+ logger.info("\n" + "=" * 80)+ logger.info("STEP 2: INITIALIZE EXTRINSICS")+ logger.info("=" * 80)++ extrinsics = initialize_extrinsics(+ board=board,+ observations_by_camera=observations_by_camera,+ intrinsics=intrinsics,+ camera_names=camera_names,+ )++ # =========================================================================+ # STEP 3: BUILD INITIAL CAMERA MODELS+ # =========================================================================+ initial_cameras: list[CameraModel] = []+ for cam_name in camera_names:+ initial_cameras.append(+ CameraModel(+ name=cam_name,+ image_size=image_sizes[cam_name],+ intrinsics=intrinsics[cam_name],+ extrinsics=extrinsics[cam_name],+ )+ )++ # =========================================================================+ # STEP 4: INITIALIZE BOARD POSES+ # =========================================================================+ logger.info("\n" + "=" * 80)+ logger.info("STEP 3: INITIALIZE BOARD POSES")+ logger.info("=" * 80)++ all_frame_indices = sorted({obs.frame_index for obs in all_observations})+ board_poses_init = initialize_board_poses(+ board=board,+ observations_by_camera=observations_by_camera,+ intrinsics=intrinsics,+ extrinsics=extrinsics,+ all_frame_indices=all_frame_indices,+ )++ # =========================================================================+ # STEP 5: BUNDLE ADJUSTMENT+ # =========================================================================+ logger.info("\n" + "=" * 80)+ logger.info("STEP 4: BUNDLE ADJUSTMENT")+ logger.info("=" * 80)++ result = run_pyceres_bundle_adjustment(+ cameras=initial_cameras,+ board=board,+ all_observations=all_observations,+ board_poses_init=board_poses_init,+ config=config,+ )++ # =========================================================================+ # STEP 6: POST-PROCESSING+ # =========================================================================+ logger.info("\n" + "=" * 80)+ logger.info("STEP 5: POST-PROCESSING")+ logger.info("=" * 80)++ final_cameras = result.cameras++ if config.pin_camera_0:+ final_cameras = pin_camera_to_origin(+ cameras=final_cameras,+ camera_index=0,+ )++ if use_groundplane:+ try:+ final_cameras = align_to_charuco_groundplane(+ cameras=final_cameras,+ board=board,+ all_observations=all_observations,+ )+ except RuntimeError as e:+ logger.warning(f"Ground plane alignment failed: {e}")++ # Rebuild result with post-processed cameras+ result = CalibrationResult(+ cameras=final_cameras,+ board=result.board,+ reprojection_error_px=result.reprojection_error_px,+ initial_cost=result.initial_cost,+ final_cost=result.final_cost,+ n_iterations=result.n_iterations,+ time_seconds=result.time_seconds,+ n_observations_used=result.n_observations_used,+ n_observations_rejected=result.n_observations_rejected,+ )++ # Log final summary+ logger.info("\n" + "=" * 80)+ logger.info("CALIBRATION COMPLETE")+ logger.info("=" * 80)+ logger.info(f" Cameras: {len(result.cameras)}")+ logger.info(f" Reprojection error: {result.reprojection_error_px:.4f} px")+ logger.info(f" Observations used: {result.n_observations_used}")+ logger.info(f" Observations rejected: {result.n_observations_rejected}")+ logger.info(f" Solver time: {result.time_seconds:.2f}s")++ for cam in result.cameras:+ pos = cam.extrinsics.world_position+ logger.info(+ f" Camera '{cam.name}': "+ f"pos=({pos[0]:.1f}, {pos[1]:.1f}, {pos[2]:.1f})mm, "+ f"fx={cam.intrinsics.fx:.1f}, fy={cam.intrinsics.fy:.1f}"+ )++ return resultdiff --git a/freemocap/core/calibration/shared/__init__.py b/freemocap/core/calibration/shared/__init__.pynew file mode 100644index 00000000..dddcc923--- /dev/null+++ b/freemocap/core/calibration/shared/__init__.py@@ -0,0 +1 @@+"""Shared utilities for calibration — used by both anipose and pyceres paths."""diff --git a/freemocap/core/calibration/shared/calibration_models.py b/freemocap/core/calibration/shared/calibration_models.pynew file mode 100644index 00000000..5f0757b3--- /dev/null+++ b/freemocap/core/calibration/shared/calibration_models.py@@ -0,0 +1,492 @@+"""Shared Pydantic data models for camera calibration.++These models are the canonical representations used by both the anipose+and pyceres calibration paths. Each solver may have additional internal+models, but data flows through these shared types at the boundaries.+"""++import toml+from pathlib import Path++import cv2+import numpy as np+from numpy.typing import NDArray+from pydantic import BaseModel, ConfigDict, field_validator, model_validator+from scipy.spatial.transform import Rotation++from freemocap.core.calibration.shared.toml_mixin import TomlMixin, numpy_to_python+++# =============================================================================+# BOARD DEFINITION+# =============================================================================+++class CharucoBoardDefinition(BaseModel, TomlMixin):+ """Known charuco board geometry — fixed, never optimized.++ Single source of truth for board parameters. Both solver paths+ construct their solver-specific board representations from this.+ """++ model_config = ConfigDict(extra="forbid", frozen=True)++ squares_x: int+ squares_y: int+ square_length_mm: float+ marker_length_mm: float+ marker_bits: int = 4+ dict_size: int = 250++ @model_validator(mode="after")+ def validate_geometry(self) -> "CharucoBoardDefinition":+ if self.marker_length_mm >= self.square_length_mm:+ raise ValueError(+ f"marker_length_mm ({self.marker_length_mm}) must be < "+ f"square_length_mm ({self.square_length_mm})"+ )+ if self.squares_x < 2 or self.squares_y < 2:+ raise ValueError(+ f"Board must have at least 2x2 squares, "+ f"got {self.squares_x}x{self.squares_y}"+ )+ return self++ @property+ def n_corners(self) -> int:+ """Number of internal corners on the board."""+ return (self.squares_x - 1) * (self.squares_y - 1)++ @property+ def corner_positions_board_frame(self) -> NDArray[np.float64]:+ """(n_corners, 3) corner positions in the board-local frame (Z=0 plane)."""+ cols = self.squares_x - 1+ rows = self.squares_y - 1+ objp = np.zeros((cols * rows, 3), dtype=np.float64)+ objp[:, :2] = np.mgrid[0:cols, 0:rows].T.reshape(-1, 2)+ objp *= self.square_length_mm+ return objp+++# =============================================================================+# INTRINSICS+# =============================================================================+++class CameraIntrinsics(BaseModel, TomlMixin):+ """Camera intrinsic parameters: focal length, principal point, distortion."""++ model_config = ConfigDict(extra="forbid")++ fx: float+ fy: float+ cx: float+ cy: float+ k1: float = 0.0+ k2: float = 0.0+ p1: float = 0.0+ p2: float = 0.0++ def to_param_array(self) -> NDArray[np.float64]:+ """Pack into 8-element array: [fx, fy, cx, cy, k1, k2, p1, p2]."""+ return np.array(+ [self.fx, self.fy, self.cx, self.cy, self.k1, self.k2, self.p1, self.p2],+ dtype=np.float64,+ )++ @classmethod+ def from_param_array(cls, params: NDArray[np.float64]) -> "CameraIntrinsics":+ """Unpack from 8-element array."""+ if params.shape != (8,):+ raise ValueError(f"Expected shape (8,), got {params.shape}")+ return cls(+ fx=float(params[0]),+ fy=float(params[1]),+ cx=float(params[2]),+ cy=float(params[3]),+ k1=float(params[4]),+ k2=float(params[5]),+ p1=float(params[6]),+ p2=float(params[7]),+ )++ def to_camera_matrix(self) -> NDArray[np.float64]:+ """3x3 camera matrix K."""+ return np.array(+ [[self.fx, 0.0, self.cx],+ [0.0, self.fy, self.cy],+ [0.0, 0.0, 1.0]],+ dtype=np.float64,+ )++ def to_dist_coeffs(self) -> NDArray[np.float64]:+ """OpenCV distortion coefficients (4-element): [k1, k2, p1, p2]."""+ return np.array([self.k1, self.k2, self.p1, self.p2], dtype=np.float64)++ def to_dist_coeffs_5(self) -> NDArray[np.float64]:+ """5-element distortion vector for anipose-compatible TOML: [k1, k2, p1, p2, 0]."""+ return np.array([self.k1, self.k2, self.p1, self.p2, 0.0], dtype=np.float64)++ @classmethod+ def from_image_size(cls, *, width: int, height: int) -> "CameraIntrinsics":+ """Naive initial guess: focal length = image width, principal point = center."""+ return cls(+ fx=float(width),+ fy=float(width),+ cx=float(width) / 2.0,+ cy=float(height) / 2.0,+ )++ @classmethod+ def from_camera_matrix_and_dist(+ cls,+ *,+ camera_matrix: NDArray[np.float64],+ dist_coeffs: NDArray[np.float64],+ ) -> "CameraIntrinsics":+ """Construct from a 3x3 camera matrix and distortion coefficients."""+ if camera_matrix.shape != (3, 3):+ raise ValueError(f"camera_matrix shape {camera_matrix.shape}, expected (3, 3)")+ dist = dist_coeffs.ravel()+ return cls(+ fx=float(camera_matrix[0, 0]),+ fy=float(camera_matrix[1, 1]),+ cx=float(camera_matrix[0, 2]),+ cy=float(camera_matrix[1, 2]),+ k1=float(dist[0]) if len(dist) > 0 else 0.0,+ k2=float(dist[1]) if len(dist) > 1 else 0.0,+ p1=float(dist[2]) if len(dist) > 2 else 0.0,+ p2=float(dist[3]) if len(dist) > 3 else 0.0,+ )+++# =============================================================================+# EXTRINSICS+# =============================================================================+++class CameraExtrinsics(BaseModel, TomlMixin):+ """Camera extrinsic parameters: orientation (quaternion wxyz) + translation."""++ model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)++ quaternion_wxyz: NDArray[np.float64]+ translation: NDArray[np.float64]++ @field_validator("quaternion_wxyz", mode="before")+ @classmethod+ def validate_quaternion(cls, v: NDArray[np.float64] | list) -> NDArray[np.float64]:+ arr = np.asarray(v, dtype=np.float64).ravel()+ if arr.shape != (4,):+ raise ValueError(f"Quaternion must have shape (4,), got {arr.shape}")+ return arr++ @field_validator("translation", mode="before")+ @classmethod+ def validate_translation(cls, v: NDArray[np.float64] | list) -> NDArray[np.float64]:+ arr = np.asarray(v, dtype=np.float64).ravel()+ if arr.shape != (3,):+ raise ValueError(f"Translation must have shape (3,), got {arr.shape}")+ return arr++ @property+ def rotation_matrix(self) -> NDArray[np.float64]:+ """3x3 rotation matrix from quaternion."""+ w, x, y, z = self.quaternion_wxyz+ return Rotation.from_quat([x, y, z, w]).as_matrix()++ @property+ def rodrigues_vector(self) -> NDArray[np.float64]:+ """3-element Rodrigues rotation vector (for OpenCV compatibility)."""+ rvec, _ = cv2.Rodrigues(self.rotation_matrix)+ return rvec.ravel()++ @property+ def world_position(self) -> NDArray[np.float64]:+ """Camera position in world coordinates: -R^T @ t."""+ return -self.rotation_matrix.T @ self.translation++ @property+ def world_orientation(self) -> NDArray[np.float64]:+ """Camera orientation as 3x3 rotation matrix (cam-to-world): R^T."""+ return self.rotation_matrix.T++ @classmethod+ def from_rodrigues(+ cls,+ *,+ rvec: NDArray[np.float64],+ tvec: NDArray[np.float64],+ ) -> "CameraExtrinsics":+ """Construct from Rodrigues rotation vector + translation."""+ rmat, _ = cv2.Rodrigues(np.asarray(rvec, dtype=np.float64).ravel())+ quat_xyzw = Rotation.from_matrix(rmat).as_quat()+ quat_wxyz = np.array(+ [quat_xyzw[3], quat_xyzw[0], quat_xyzw[1], quat_xyzw[2]],+ )+ return cls(+ quaternion_wxyz=quat_wxyz,+ translation=np.asarray(tvec, dtype=np.float64).ravel(),+ )++ @classmethod+ def identity(cls) -> "CameraExtrinsics":+ """Identity transform (no rotation, no translation)."""+ return cls(+ quaternion_wxyz=np.array([1.0, 0.0, 0.0, 0.0]),+ translation=np.zeros(3, dtype=np.float64),+ )+++# =============================================================================+# CAMERA MODEL+# =============================================================================+++class CameraModel(BaseModel, TomlMixin):+ """Complete camera model: intrinsics + extrinsics + metadata."""++ model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)++ name: str+ image_size: tuple[int, int] # (width, height)+ intrinsics: CameraIntrinsics+ extrinsics: CameraExtrinsics++ @property+ def projection_matrix(self) -> NDArray[np.float64]:+ """Full 3x4 projection matrix P = K @ [R|t]."""+ K = self.intrinsics.to_camera_matrix()+ R = self.extrinsics.rotation_matrix+ t = self.extrinsics.translation+ Rt = np.zeros((3, 4), dtype=np.float64)+ Rt[:, :3] = R+ Rt[:, 3] = t+ return K @ Rt+++# =============================================================================+# OBSERVATIONS+# =============================================================================+++class CornerObservation(BaseModel):+ """A single detected charuco corner in pixel coordinates."""++ model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)++ corner_id: int+ pixel_xy: NDArray[np.float64]++ @field_validator("pixel_xy", mode="before")+ @classmethod+ def validate_pixel(cls, v: NDArray[np.float64] | list | tuple) -> NDArray[np.float64]:+ arr = np.asarray(v, dtype=np.float64).ravel()+ if arr.shape != (2,):+ raise ValueError(f"pixel_xy must have shape (2,), got {arr.shape}")+ return arr+++class CharucoCornersObservation(BaseModel):+ """All charuco corners detected by one camera in one frame."""++ model_config = ConfigDict(extra="forbid")++ camera_name: str+ frame_index: int+ corners: list[CornerObservation]++ @property+ def n_corners(self) -> int:+ return len(self.corners)++ @property+ def corner_ids(self) -> list[int]:+ return [c.corner_id for c in self.corners]+++# =============================================================================+# CALIBRATION RESULT+# =============================================================================++++class CalibrationResult(BaseModel, TomlMixin):+ """Output of either calibration pipeline.++ Both the anipose and pyceres paths produce this type. It can be+ serialized to/from the anipose-compatible TOML format.++ Provides get_triangulator() and get_triangulator_for_cameras() to+ build a Triangulator for downstream 3D reconstruction without any+ anipose dependency.+ """++ model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)++ cameras: list[CameraModel]+ board: CharucoBoardDefinition+ reprojection_error_px: float+ initial_cost: float+ final_cost: float+ n_iterations: int+ time_seconds: float+ n_observations_used: int+ n_observations_rejected: int++ @property+ def camera_names(self) -> list[str]:+ return [c.name for c in self.cameras]++ def get_camera(self, name: str) -> CameraModel:+ """Look up a camera by name."""+ for cam in self.cameras:+ if cam.name == name:+ return cam+ raise KeyError(f"Camera '{name}' not found. Available: {self.camera_names}")++ # ---- Triangulator construction ----++ def get_triangulator(self) -> "Triangulator":+ """Build a Triangulator from this calibration's cameras.++ The Triangulator performs DLT triangulation directly from CameraModel+ intrinsics/extrinsics with no anipose dependency.+ """+ from freemocap.core.calibration.shared.triangulator import Triangulator+ return Triangulator.from_calibration_result(calibration=self)++ def get_triangulator_for_cameras(self, camera_ids: list[str]) -> "Triangulator":+ """Build a Triangulator with cameras ordered to match the given IDs.++ Use this when the current session's cameras may be a subset of,+ or in a different order than, the calibration's cameras.++ Raises:+ KeyError: If any camera_id is not found in this calibration.+ """+ from freemocap.core.calibration.shared.triangulator import Triangulator++ return Triangulator.from_calibration_for_cameras(+ calibration=self,+ camera_ids=camera_ids,+ )++ # ---- Anipose-compatible TOML (same as existing) ----++ def dump_anipose_toml(+ self,+ path: Path,+ metadata: dict | None = None,+ ) -> None:+ """Write anipose-compatible TOML."""+ cameras_dict: dict[str, object] = {}++ for cam in self.cameras:+ cameras_dict[cam.name] = {+ "name": cam.name,+ "size": list(cam.image_size),+ "matrix": cam.intrinsics.to_camera_matrix().tolist(),+ "distortions": cam.intrinsics.to_dist_coeffs_5().tolist(),+ "rotation": cam.extrinsics.rodrigues_vector.tolist(),+ "translation": cam.extrinsics.translation.tolist(),+ "world_orientation": cam.extrinsics.world_orientation.tolist(),+ "world_position": cam.extrinsics.world_position.tolist(),+ }++ meta = metadata.copy() if metadata else {}+ meta["reprojection_error_px"] = self.reprojection_error_px+ meta["n_observations_used"] = self.n_observations_used+ meta["n_observations_rejected"] = self.n_observations_rejected+ meta["solver_time_seconds"] = self.time_seconds+ meta["board"] = {+ "squares_x": self.board.squares_x,+ "squares_y": self.board.squares_y,+ "square_length_mm": self.board.square_length_mm,+ "marker_length_mm": self.board.marker_length_mm,+ "marker_bits": self.board.marker_bits,+ "dict_size": self.board.dict_size,+ }+ cameras_dict["metadata"] = numpy_to_python(meta)++ path = Path(path)+ path.parent.mkdir(parents=True, exist_ok=True)+ path.write_text(toml.dumps(cameras_dict))++ @classmethod+ def load_anipose_toml(cls, path: Path) -> "CalibrationResultUpdated":+ """Load from an anipose-compatible TOML calibration file."""+ path = Path(path)+ if not path.is_file():+ raise FileNotFoundError(f"Calibration file not found: {path}")++ toml_data = toml.load(path)+ metadata = toml_data.pop("metadata", {})++ cameras: list[CameraModel] = []+ for key in sorted(toml_data.keys()):+ d = toml_data[key]+ if "name" not in d:+ raise ValueError(f"TOML key '{key}' missing 'name' field")++ if "size" in d:+ size = (int(d["size"][0]), int(d["size"][1]))+ elif "image_size" in d:+ size = (int(d["image_size"][0]), int(d["image_size"][1]))+ else:+ raise KeyError(f"Camera '{key}' missing 'size' or 'image_size'")++ K = np.array(d["matrix"], dtype=np.float64)+ if K.shape != (3, 3):+ raise ValueError(f"Camera '{key}': matrix shape {K.shape}, expected (3, 3)")++ dist = np.array(d["distortions"], dtype=np.float64).ravel()++ intrinsics = CameraIntrinsics(+ fx=float(K[0, 0]),+ fy=float(K[1, 1]),+ cx=float(K[0, 2]),+ cy=float(K[1, 2]),+ k1=float(dist[0]) if len(dist) > 0 else 0.0,+ k2=float(dist[1]) if len(dist) > 1 else 0.0,+ p1=float(dist[2]) if len(dist) > 2 else 0.0,+ p2=float(dist[3]) if len(dist) > 3 else 0.0,+ )++ rvec = np.array(d["rotation"], dtype=np.float64).ravel()+ tvec = np.array(d["translation"], dtype=np.float64).ravel()+ extrinsics = CameraExtrinsics.from_rodrigues(rvec=rvec, tvec=tvec)++ cameras.append(+ CameraModel(+ name=str(d["name"]),+ image_size=size,+ intrinsics=intrinsics,+ extrinsics=extrinsics,+ )+ )++ if len(cameras) == 0:+ raise ValueError(f"No cameras found in {path}")++ board_meta = metadata.get("board", {})+ board = CharucoBoardDefinition(+ squares_x=board_meta.get("squares_x", 7),+ squares_y=board_meta.get("squares_y", 5),+ square_length_mm=board_meta.get("square_length_mm", 1.0),+ marker_length_mm=board_meta.get("marker_length_mm", 0.8),+ marker_bits=board_meta.get("marker_bits", 4),+ dict_size=board_meta.get("dict_size", 250),+ )++ return cls(+ cameras=cameras,+ board=board,+ reprojection_error_px=metadata.get("reprojection_error_px", 0.0),+ initial_cost=metadata.get("initial_cost", 0.0),+ final_cost=metadata.get("final_cost", 0.0),+ n_iterations=metadata.get("n_iterations", 0),+ time_seconds=metadata.get("solver_time_seconds", 0.0),+ n_observations_used=metadata.get("n_observations_used", 0),+ n_observations_rejected=metadata.get("n_observations_rejected", 0),+ )diff --git a/freemocap/core/calibration/shared/calibration_paths.py b/freemocap/core/calibration/shared/calibration_paths.pynew file mode 100644index 00000000..a159a40c--- /dev/null+++ b/freemocap/core/calibration/shared/calibration_paths.py@@ -0,0 +1,25 @@+"""Shared calibration file path utilities.++Used by both the anipose and pyceres calibration paths.+"""++from pathlib import Path++from freemocap.system.default_paths import get_default_freemocap_base_folder_path++LAST_SUCCESSFUL_CAMERA_CALIBRATION_STRING = "last_successful_camera_calibration"+++def get_calibrations_folder_path() -> Path:+ """Get the main calibrations folder path."""+ return Path(get_default_freemocap_base_folder_path()) / "calibrations"+++def create_camera_calibration_file_name(recording_name: str) -> str:+ """Create a standardized camera calibration filename."""+ return f"{recording_name}_camera_calibration.toml"+++def get_last_successful_calibration_toml_path() -> Path:+ """Get the path for the last successful calibration TOML file."""+ return get_calibrations_folder_path() / f"{LAST_SUCCESSFUL_CAMERA_CALIBRATION_STRING}.toml"diff --git a/freemocap/core/calibration/shared/calibration_save.py b/freemocap/core/calibration/shared/calibration_save.pynew file mode 100644index 00000000..082961b5--- /dev/null+++ b/freemocap/core/calibration/shared/calibration_save.py@@ -0,0 +1,51 @@+"""Shared calibration-file save logic.++Both the anipose and pyceres paths save calibration results to three locations:+ 1. The recording folder+ 2. The main calibrations folder+ 3. The 'last successful' calibration path++This module provides a single function to handle all three.+"""++import logging+from collections.abc import Callable+from pathlib import Path++from freemocap.core.calibration.shared.calibration_paths import create_camera_calibration_file_name, \+ get_calibrations_folder_path, get_last_successful_calibration_toml_path++logger = logging.getLogger(__name__)+++def save_calibration_copies(+ *,+ save_fn: Callable[[Path], None],+ recording_name: str,+ recording_folder_path: str | Path,+) -> Path:+ """Save a calibration to all three standard locations.++ Args:+ save_fn: Callable that writes the calibration data to a given path.+ recording_name: Name of the recording (used to build the filename).+ recording_folder_path: Path to the recording folder.++ Returns:+ Path to the calibration file in the recording folder (primary copy).+ """+ filename = create_camera_calibration_file_name(recording_name=recording_name)++ recording_toml = Path(recording_folder_path) / filename+ save_fn(recording_toml)+ logger.info(f"Saved calibration to recording folder: {recording_toml}")++ calibration_folder_toml = get_calibrations_folder_path() / filename+ save_fn(calibration_folder_toml)+ logger.info(f"Saved calibration to calibrations folder: {calibration_folder_toml}")++ last_successful = get_last_successful_calibration_toml_path()+ save_fn(last_successful)+ logger.info(f"Saved as last successful calibration: {last_successful}")++ return recording_tomldiff --git a/freemocap/core/calibration/shared/calibration_state.py b/freemocap/core/calibration/shared/calibration_state.pynew file mode 100644index 00000000..dc2d9e70--- /dev/null+++ b/freemocap/core/calibration/shared/calibration_state.py@@ -0,0 +1,287 @@+"""CalibrationStateTracker: wraps calibration with validity tracking.++Uses Triangulator (pure CameraModel-based DLT) instead of AniposeCameraGroup.+Provides optimistic loading, graceful degradation on repeated triangulation+failure, and periodic file-change detection for hot-reloading.+"""++import logging+import os+from pathlib import Path++import numpy as np+from numpy.typing import NDArray+from skellycam.core.types.type_overloads import CameraIdString+from skellytracker.trackers.base_tracker.base_tracker_abcs import BaseObservation++from freemocap.core.calibration.shared.calibration_models import CalibrationResult+from freemocap.core.calibration.shared.calibration_paths import get_last_successful_calibration_toml_path+from freemocap.core.calibration.shared.triangulator import Triangulator++logger = logging.getLogger(__name__)++# Invalidate calibration after this many consecutive triangulation failures+MAX_CONSECUTIVE_FAILURES: int = 10+++class CalibrationStateTracker:+ """Tracks whether we have a valid calibration and provides safe triangulation.++ Uses the pure Triangulator (DLT from CameraModel) rather than AniposeCameraGroup.++ Lifecycle:+ 1. On creation, optimistically try to load the latest calibration.+ 2. Triangulation requests go through try_triangulate(), which returns+ None if no valid calibration is loaded.+ 3. If triangulation fails repeatedly (MAX_CONSECUTIVE_FAILURES), the+ calibration is invalidated. A single bad frame does not kill 3D.+ 4. check_for_update() polls the calibration file mtime and reloads+ if the file has changed. Existing calibration is preserved if the+ file is unchanged or if loading the new file fails.+ """++ def __init__(self) -> None:+ self._calibration: CalibrationResult | None = None+ self._triangulator: Triangulator | None = None+ self._is_valid: bool = False+ self._consecutive_failure_count: int = 0+ self._calibration_path: Path | None = None+ self._calibration_file_mtime: float | None = None++ @classmethod+ def create_and_try_load(cls) -> "CalibrationStateTracker":+ """Create a tracker and optimistically try to load the latest calibration."""+ tracker = cls()+ tracker._try_load_latest()+ return tracker++ @property+ def is_valid(self) -> bool:+ return self._is_valid and self._triangulator is not None++ @property+ def calibration_path(self) -> Path | None:+ return self._calibration_path++ def check_for_update(self) -> bool:+ """Check if the calibration file on disk has changed, and reload if so.++ Safe to call frequently (e.g. once per second). Does nothing if+ the file is unchanged or missing. Preserves existing calibration+ if the new file fails to load.++ Returns:+ True if a new calibration was loaded.+ """+ try:+ path = get_last_successful_calibration_toml_path()+ if not path.exists():+ return False+ mtime = os.path.getmtime(path)+ if mtime == self._calibration_file_mtime:+ return False+ logger.info(+ f"Calibration file changed on disk at {path} "+ f"(mtime={mtime}, previous_mtime={self._calibration_file_mtime})"+ )+ return self._try_load_from_path(path)+ except Exception as e:+ logger.debug(f"Error checking calibration file: {e}")+ return False++ def _try_load_latest(self) -> bool:+ """Try to load the most recent calibration file from the default path.++ Returns:+ True if calibration was loaded successfully.+ """+ try:+ path = get_last_successful_calibration_toml_path()+ if path.exists():+ logger.info(f"Found calibration file at {path}")+ return self._try_load_from_path(path)+ else:+ logger.debug(f"No calibration file found at {path}")+ return False+ except Exception as e:+ logger.debug(f"No existing calibration found: {e}")+ return False++ def _try_load_from_path(self, path: Path) -> bool:+ """Attempt to load calibration from an anipose-format TOML file.++ On success, replaces the current calibration state.+ On failure, logs the error and leaves the existing state untouched.++ Returns:+ True if calibration was loaded successfully.+ """+ try:+ calibration = CalibrationResult.load_anipose_toml(path)+ cameras = calibration.cameras+ triangulator = Triangulator(cameras=cameras)++ # Only swap state after everything succeeded+ self._triangulator = triangulator+ self._calibration = calibration+ self._calibration_path = path+ self._is_valid = True+ self._consecutive_failure_count = 0+ self._calibration_file_mtime = os.path.getmtime(path)+ logger.info(+ f"Loaded calibration from {path} with "+ f"{len(cameras)} cameras: {[c.name for c in cameras]}"+ )+ return True+ except Exception as e:+ logger.warning(f"Failed to load calibration from {path}: {e}", exc_info=True)+ return False++ def try_triangulate(+ self,+ *,+ frame_number: int,+ frame_observations_by_camera: dict[CameraIdString, BaseObservation],+ max_reprojection_error_px: float,+ ) -> dict[str, NDArray[np.float64]] | None:+ """Attempt triangulation with reprojection error gating.++ Uses to_tracked_points() to get named 2D observations from each camera,+ finds points visible in ≥2 cameras, triangulates via DLT, and rejects+ points whose mean reprojection error exceeds max_reprojection_error_px.++ Returns the triangulated 3D points as a dict of {point_name: xyz},+ or None if no valid calibration is loaded or triangulation failed.+ """+ if not self.is_valid:+ return None++ try:+ calibration_camera_names = self._triangulator.camera_names++ # Collect named 2D points per calibration camera+ tracked_by_cam: dict[str, dict[str, NDArray[np.float64]]] = {}+ for cam_id, obs in frame_observations_by_camera.items():+ matched_name = _match_camera_name(+ cam_id=cam_id,+ calibration_camera_names=calibration_camera_names,+ )+ if matched_name is None:+ continue+ tracked_by_cam[matched_name] = {+ name: np.asarray(pt, dtype=np.float64)[:2]+ for name, pt in obs.to_tracked_points().items()+ }++ if len(tracked_by_cam) < 2:+ return {}++ # Build subset triangulator if we don't have all cameras+ active_cam_names = sorted(tracked_by_cam.keys())+ if set(active_cam_names) != set(calibration_camera_names):+ sub_triangulator = Triangulator(+ cameras=[+ cam for cam in self._triangulator.cameras+ if cam.name in tracked_by_cam+ ]+ )+ else:+ sub_triangulator = self._triangulator+ ordered_cam_names: list[str] = sub_triangulator.camera_names+ n_cameras = len(ordered_cam_names)++ # Find all point names and count how many cameras see each+ all_point_names: set[str] = set()+ for pts in tracked_by_cam.values():+ all_point_names.update(pts.keys())++ # Keep only points visible in ≥2 cameras+ point_names: list[str] = sorted(+ name for name in all_point_names+ if sum(1 for cam in ordered_cam_names if name in tracked_by_cam[cam]) >= 2+ )++ if not point_names:+ return {}++ n_points = len(point_names)++ # Build (n_cameras, n_points, 2) array with NaN for missing observations+ stacked = np.full((n_cameras, n_points, 2), np.nan, dtype=np.float64)+ for cam_idx, cam_name in enumerate(ordered_cam_names):+ cam_points = tracked_by_cam[cam_name]+ for pt_idx, pt_name in enumerate(point_names):+ if pt_name in cam_points:+ stacked[cam_idx, pt_idx, :] = cam_points[pt_name]++ # Triangulate: (n_cameras, 1, n_points, 2) → (1, n_points, 3)+ triangulated = sub_triangulator.triangulate_array(+ data2d=stacked[:, np.newaxis, :, :],+ )+ points_3d = triangulated[0] # (n_points, 3)++ # Reprojection error gate+ mean_reproj_error = sub_triangulator.mean_reprojection_error(+ points_3d=points_3d,+ points_2d=stacked,+ ) # (n_points,)+ bad_mask = mean_reproj_error > max_reprojection_error_px+ if np.any(bad_mask):+ points_3d[bad_mask] = np.nan++ # Rotate 180° about X (freemocap convention: flip Y and Z)+ rotation_matrix = np.array([[1, 0, 0], [0, -1, 0], [0, 0, -1]])+ points_3d = points_3d @ rotation_matrix.T++ # Build result dict, excluding NaN points+ result: dict[str, NDArray[np.float64]] = {}+ for i, name in enumerate(point_names):+ if not np.isnan(points_3d[i]).any():+ result[name] = points_3d[i]++ # Triangulation succeeded — reset failure counter+ self._consecutive_failure_count = 0+ return result++ except Exception as e:+ self._consecutive_failure_count += 1+ if self._consecutive_failure_count >= MAX_CONSECUTIVE_FAILURES:+ logger.error(+ f"Triangulation failed {self._consecutive_failure_count} times "+ f"consecutively — invalidating calibration. Last error: {e}",+ exc_info=True,+ )+ self._invalidate()+ else:+ logger.warning(+ f"Triangulation failed (failure "+ f"{self._consecutive_failure_count}/{MAX_CONSECUTIVE_FAILURES}): {e}",+ )+ return None++ def _invalidate(self) -> None:+ self._is_valid = False+ self._triangulator = None+ self._calibration = None+ self._calibration_path = None+ # Preserve _calibration_file_mtime so we can detect when the file changes+++def _match_camera_name(+ *,+ cam_id: CameraIdString,+ calibration_camera_names: list[str],+) -> str | None:+ """Match a runtime camera ID to a calibration camera name.++ Uses exact string matching only. Returns None (with a warning) if+ no match is found.+ """+ if cam_id in calibration_camera_names:+ return cam_id++ logger.warning(+ f"Camera '{cam_id}' has no exact match in calibration cameras "+ f"{calibration_camera_names} — skipping this camera for triangulation"+ )+ return None\ No newline at end of filediff --git a/freemocap/core/calibration/shared/camera_identity.py b/freemocap/core/calibration/shared/camera_identity.pynew file mode 100644index 00000000..6c41b77e--- /dev/null+++ b/freemocap/core/calibration/shared/camera_identity.py@@ -0,0 +1,139 @@+"""Camera identity: extract and match camera IDs across recordings.++Camera IDs are the stable link between calibration and future recordings.+They must survive the round-trip: hardware → video filename → calibration TOML → triangulation.++The canonical camera ID comes from CameraConfig.camera_id (a CameraIdString like "000").+Video filenames are expected to encode this ID in a parseable way.+"""++import logging+import re+from pathlib import Path++from pydantic import BaseModel, ConfigDict, model_validator++logger = logging.getLogger(__name__)++# Patterns to try, in priority order, when extracting a camera ID from a filename.+# Each pattern should have a single capture group for the camera ID.+_CAMERA_ID_PATTERNS: list[re.Pattern[str]] = [+ # "rec1_camera_000.mp4" or "recording_camera_12.avi"+ re.compile(r"camera[_\-](\d+)", re.IGNORECASE),+ # "rec1_cam000.mp4"+ re.compile(r"cam(\d+)", re.IGNORECASE),+ # "000.mp4" — bare numeric filename (common in freemocap recordings)+ re.compile(r"^(\d+)\.[a-zA-Z0-9]+$"),+]+++def extract_camera_id_from_filename(video_path: Path | str) -> str | None:+ """Try to extract a camera ID from a video filename.++ Returns the extracted camera ID string, or None if no pattern matched.+ """+ filename = Path(video_path).name++ for pattern in _CAMERA_ID_PATTERNS:+ match = pattern.search(filename)+ if match:+ return match.group(1)++ return None+++def camera_ids_from_video_paths(+ video_paths: list[Path | str],+) -> dict[str, Path]:+ """Extract camera IDs from a list of video paths.++ Returns a dict mapping camera_id → video_path.++ If camera IDs can be extracted from filenames, those are used.+ If extraction fails for ANY video, falls back to sorted positional+ indices for ALL videos (to avoid mixing strategies).++ Raises:+ ValueError: If extracted camera IDs have duplicates.+ """+ paths = [Path(p) for p in sorted(video_paths, key=lambda p: str(p))]++ # Try extracting IDs from filenames+ extracted: list[str | None] = [+ extract_camera_id_from_filename(p) for p in paths+ ]++ if all(eid is not None for eid in extracted):+ ids = [eid for eid in extracted if eid is not None] # appease type checker+ if len(set(ids)) != len(ids):+ raise ValueError(+ f"Duplicate camera IDs extracted from filenames: {ids}"+ )+ logger.info(f"Extracted camera IDs from filenames: {ids}")+ return {cam_id: path for cam_id, path in zip(ids, paths)}++ # Fallback: positional indices+ logger.warning(+ "Could not extract camera IDs from all video filenames. "+ "Falling back to positional indices. "+ f"Extraction results: {list(zip([p.name for p in paths], extracted))}"+ )+ return {str(i): path for i, path in enumerate(paths)}+++class CameraGroupIdentity(BaseModel):+ """Maps camera IDs to their calibrated camera models.++ Ensures a consistent, explicit mapping between the camera IDs used+ in a recording session and the camera parameters from calibration.+ """++ model_config = ConfigDict(extra="forbid", frozen=True)++ camera_ids: list[str]++ @model_validator(mode="after")+ def _validate_unique(self) -> "CameraGroupIdentity":+ if len(set(self.camera_ids)) != len(self.camera_ids):+ raise ValueError(+ f"Camera IDs must be unique, got: {self.camera_ids}"+ )+ if len(self.camera_ids) < 1:+ raise ValueError("Must have at least one camera ID")+ return self++ @property+ def n_cameras(self) -> int:+ return len(self.camera_ids)++ def index_of(self, camera_id: str) -> int:+ """Get the index of a camera ID. Raises ValueError if not found."""+ try:+ return self.camera_ids.index(camera_id)+ except ValueError:+ raise ValueError(+ f"Camera '{camera_id}' not in group. Known: {self.camera_ids}"+ )++ def validate_against_calibration_names(+ self,+ calibration_camera_names: list[str],+ ) -> None:+ """Verify all our camera IDs exist in the calibration.++ Raises:+ KeyError: If any camera ID is missing from the calibration.+ """+ cal_set = set(calibration_camera_names)+ missing = [cid for cid in self.camera_ids if cid not in cal_set]+ if missing:+ raise KeyError(+ f"Cameras {missing} not found in calibration. "+ f"Calibration has: {calibration_camera_names}"+ )++ @classmethod+ def from_video_paths(cls, video_paths: list[Path | str]) -> "CameraGroupIdentity":+ """Build a CameraGroupIdentity by extracting IDs from video filenames."""+ id_to_path = camera_ids_from_video_paths(video_paths=video_paths)+ return cls(camera_ids=list(id_to_path.keys()))diff --git a/freemocap/core/calibration/shared/charuco_observation_aggregator.py b/freemocap/core/calibration/shared/charuco_observation_aggregator.pynew file mode 100644index 00000000..f76a8490--- /dev/null+++ b/freemocap/core/calibration/shared/charuco_observation_aggregator.py@@ -0,0 +1,62 @@+"""Aggregates charuco observations into anipose-compatible row format.++Used only by the anipose calibration path.+"""++from pydantic import BaseModel, Field+from skellycam.core.types.type_overloads import CameraIdString+from skellytracker.trackers.charuco_tracker.charuco_observation import CharucoObservation++CharucoObservations = dict[CameraIdString, CharucoObservation | None]+++class CharucoObservationAggregator(BaseModel):+ """Collects charuco observations across frames into anipose row format."""++ anipose_camera_ordering: list[CameraIdString]+ individual_camera_rows: dict[CameraIdString, list] = Field(default_factory=dict)++ @classmethod+ def from_charuco_observation_payload(+ cls,+ charuco_observations_by_camera: CharucoObservations,+ anipose_camera_ordering: list[CameraIdString],+ ) -> "CharucoObservationAggregator":+ if set(charuco_observations_by_camera.keys()) != set(anipose_camera_ordering):+ raise ValueError("individual_camera_rows and anipose_camera_ordering must have the same camera ids")++ camera_rows: dict[CameraIdString, list] = {}+ for camera_id, charuco_observation in charuco_observations_by_camera.items():+ if charuco_observation is None:+ raise ValueError(+ "Cannot create CharucoObservationAggregator from payload with None observations "+ "— use nan-filled CharucoObservation instead"+ )+ anipose_camera_row = charuco_observation.to_anipose_camera_row()+ if anipose_camera_row is None:+ raise ValueError(+ "Cannot create CharucoObservationAggregator from payload with None anipose row "+ "— use nan-filled CharucoObservation instead"+ )+ camera_rows[camera_id] = [anipose_camera_row]++ return cls(individual_camera_rows=camera_rows, anipose_camera_ordering=anipose_camera_ordering)++ @property+ def all_camera_rows(self) -> list[list]:+ return [self.individual_camera_rows[cam_id] for cam_id in self.anipose_camera_ordering]++ def add_observations(self, charuco_observations_by_camera: CharucoObservations) -> None:+ for camera_id, charuco_observation in charuco_observations_by_camera.items():+ if charuco_observation is None:+ raise ValueError(+ "Cannot add None observations to CharucoObservationAggregator "+ "— use nan-filled CharucoObservation instead"+ )+ anipose_camera_row = charuco_observation.to_anipose_camera_row()+ if anipose_camera_row is None:+ raise ValueError(+ "Cannot add None anipose row to CharucoObservationAggregator "+ "— use nan-filled CharucoObservation instead"+ )+ self.individual_camera_rows[camera_id].append(anipose_camera_row)diff --git a/freemocap/core/calibration/shared/groundplane_math.py b/freemocap/core/calibration/shared/groundplane_math.pynew file mode 100644index 00000000..bd97c96d--- /dev/null+++ b/freemocap/core/calibration/shared/groundplane_math.py@@ -0,0 +1,140 @@+"""Shared ground-plane alignment math for camera calibration.++Contains format-agnostic functions for computing the charuco board's+coordinate frame from triangulated 3D corners and finding a frame+where the board is stationary.++Used by both the anipose and pyceres calibration paths.+"""++import numpy as np+from numpy.typing import NDArray+++class CharucoVisibilityError(RuntimeError):+ """Raised when no frame satisfies the 'all-corners-visible & stationary' criteria."""+++class CharucoVelocityError(RuntimeError):+ """Raised when the velocity of the ChArUco corners is too high to be considered stationary."""+++def get_charuco_key_corner_indices(+ squares_x: int,+ squares_y: int,+) -> tuple[int, int]:+ """Get the corner indices that define the board's X and Y axes.++ For a board with ``squares_x`` columns and ``squares_y`` rows, the internal+ corners form a grid of ``(squares_x-1) x (squares_y-1)``. Corner 0 is the+ origin, the returned ``idx_x`` is at the far end of the X axis, and ``idx_y``+ is at the far end of the Y axis.++ Args:+ squares_x: Number of squares in the X (width) direction.+ squares_y: Number of squares in the Y (height) direction.++ Returns:+ Tuple of (idx_x, idx_y) corner indices.+ """+ num_cols = squares_x - 1+ num_rows = squares_y - 1+ idx_x = num_cols * (num_rows - 1)+ idx_y = num_cols - 1+ return idx_x, idx_y+++def compute_board_basis_vectors(+ charuco_frame: NDArray[np.float64],+ squares_x: int,+ squares_y: int,+) -> tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]:+ """Compute orthonormal basis vectors of the charuco board's coordinate frame.++ X axis: from corner 0 toward ``idx_x``.+ Y axis: orthogonal to X in the board plane.+ Z axis: board normal (X × Y, pointing "up").++ Args:+ charuco_frame: (n_corners, 3) array of 3D corner positions for one frame.+ squares_x: Number of squares in the X direction.+ squares_y: Number of squares in the Y direction.++ Returns:+ Tuple of (x_hat, y_hat, z_hat) unit vectors.+ """+ origin = charuco_frame[0]+ idx_x, idx_y = get_charuco_key_corner_indices(squares_x=squares_x, squares_y=squares_y)++ x_vec = charuco_frame[idx_x] - origin+ y_vec = charuco_frame[idx_y] - origin++ x_hat = x_vec / np.linalg.norm(x_vec)+ y_hat_raw = y_vec / np.linalg.norm(y_vec)+ z_hat = np.cross(x_hat, y_hat_raw)+ z_hat = z_hat / np.linalg.norm(z_hat)+ y_hat = np.cross(z_hat, x_hat)+ y_hat = y_hat / np.linalg.norm(y_hat)++ return x_hat, y_hat, z_hat+++def find_still_charuco_frame(+ charuco_3d: NDArray[np.float64],+ squares_x: int,+ squares_y: int,+ search_start: int = 0,+ search_range: int = 120,+) -> int:+ """Find the frame where the charuco board is most stationary.++ Examines the origin, X-axis-end, and Y-axis-end corners. Picks the frame+ (within the search range) where the maximum corner velocity is minimized.++ Args:+ charuco_3d: (n_frames, n_corners, 3) triangulated 3D corner positions.+ squares_x: Board squares in X.+ squares_y: Board squares in Y.+ search_start: Frame index to start searching from.+ search_range: Number of frames to search.++ Returns:+ Frame index (into ``charuco_3d``) of the stillest frame.++ Raises:+ CharucoVisibilityError: No frame has all three key corners visible.+ CharucoVelocityError: All visible frames have velocity above threshold.+ """+ n_frames = charuco_3d.shape[0]+ idx_x, idx_y = get_charuco_key_corner_indices(squares_x=squares_x, squares_y=squares_y)+ key_indices = [0, idx_y, idx_x]++ # Compute search slice+ start = max(0, search_start)+ end = min(n_frames, start + search_range)+ if end <= start:+ raise CharucoVisibilityError("Search range is empty — not enough frames.")++ key_corners = charuco_3d[start:end, key_indices, :] # (range, 3_corners, 3_xyz)+ velocity = np.linalg.norm(np.diff(key_corners, axis=0), axis=2) # (range-1, 3_corners)++ visible = ~np.isnan(velocity).any(axis=1)+ if not visible.any():+ raise CharucoVisibilityError(+ "No frame found where all three key ChArUco corners are visible and have valid velocity."+ )++ max_velocity_per_frame = np.nanmax(velocity[visible], axis=1)++ MAX_ALLOWED_VELOCITY = 1.0+ if np.nanmin(max_velocity_per_frame) > MAX_ALLOWED_VELOCITY:+ raise CharucoVelocityError(+ f"All frames have ChArUco corner velocity > {MAX_ALLOWED_VELOCITY:.2f} — "+ f"check that the board is stationary."+ )++ best_visible_idx = int(np.nanargmin(max_velocity_per_frame))+ # +1 because np.diff shifts indices by 1+ best_frame_idx = np.where(visible)[0][best_visible_idx] + 1 + start++ return best_frame_idxdiff --git a/freemocap/core/calibration/shared/toml_mixin.py b/freemocap/core/calibration/shared/toml_mixin.pynew file mode 100644index 00000000..061c14dc--- /dev/null+++ b/freemocap/core/calibration/shared/toml_mixin.py@@ -0,0 +1,66 @@+"""TOML serialization mixin for Pydantic models.++Provides model_dump_toml / model_validate_toml methods that mirror+the Pydantic model_dump_json / model_validate_json interface.++Uses the ``toml`` package for reading and writing.+"""++from pathlib import Path+from typing import Self++import numpy as np+import toml+from pydantic import BaseModel+++def numpy_to_python(obj: object) -> object:+ """Recursively convert numpy types to native Python types for TOML."""+ if isinstance(obj, np.ndarray):+ return obj.tolist()+ if isinstance(obj, np.integer):+ return int(obj)+ if isinstance(obj, np.floating):+ return float(obj)+ if isinstance(obj, dict):+ return {k: numpy_to_python(v) for k, v in obj.items()}+ if isinstance(obj, list):+ return [numpy_to_python(v) for v in obj]+ if isinstance(obj, tuple):+ return [numpy_to_python(v) for v in obj]+ return obj+++class TomlMixin:+ """Mixin that adds TOML serialization to Pydantic BaseModel subclasses.++ Add as a base class alongside BaseModel:+ class MyModel(BaseModel, TomlMixin): ...+ """++ def model_dump_toml(self: BaseModel) -> str:+ """Serialize model to a TOML string."""+ data = self.model_dump(mode="python")+ data = numpy_to_python(data)+ return toml.dumps(data)++ def model_dump_toml_file(self: BaseModel, path: Path) -> None:+ """Serialize model to a TOML file."""+ path = Path(path)+ path.parent.mkdir(parents=True, exist_ok=True)+ path.write_text(self.model_dump_toml())++ @classmethod+ def model_validate_toml(cls, toml_string: str) -> Self:+ """Deserialize model from a TOML string."""+ data = toml.loads(toml_string)+ return cls.model_validate(data)++ @classmethod+ def model_validate_toml_file(cls, path: Path) -> Self:+ """Deserialize model from a TOML file."""+ path = Path(path)+ if not path.is_file():+ raise FileNotFoundError(f"TOML file not found: {path}")+ data = toml.load(path)+ return cls.model_validate(data)\ No newline at end of filediff --git a/freemocap/core/calibration/shared/transform_math.py b/freemocap/core/calibration/shared/transform_math.pynew file mode 100644index 00000000..781b8c42--- /dev/null+++ b/freemocap/core/calibration/shared/transform_math.py@@ -0,0 +1,309 @@+"""Shared rigid-transform math for camera calibration.++Contains format-agnostic functions for working with 4x4 rigid transforms:+robust averaging via clustering, spanning tree construction, etc.++Used by both the anipose and pyceres calibration paths.+"""++import logging+import queue+from collections import Counter, defaultdict++import cv2+import numpy as np+from numpy.typing import NDArray+from scipy.cluster.hierarchy import linkage, fcluster+from scipy.cluster.vq import whiten++logger = logging.getLogger(__name__)+++def make_M(rvec: NDArray[np.float64], tvec: NDArray[np.float64]) -> NDArray[np.float64]:+ """Build a 4x4 rigid transformation matrix from a Rodrigues rotation vector and translation.++ Args:+ rvec: (3,) Rodrigues rotation vector.+ tvec: (3,) translation vector.++ Returns:+ (4, 4) homogeneous transformation matrix.+ """+ rvec = np.asarray(rvec, dtype=np.float64).ravel()+ tvec = np.asarray(tvec, dtype=np.float64).ravel()+ R, _ = cv2.Rodrigues(rvec)+ M = np.eye(4, dtype=np.float64)+ M[:3, :3] = R+ M[:3, 3] = tvec+ return M+++def get_rtvec(M: NDArray[np.float64]) -> tuple[NDArray[np.float64], NDArray[np.float64]]:+ """Extract Rodrigues rotation vector and translation from a 4x4 transform.++ Args:+ M: (4, 4) homogeneous transformation matrix.++ Returns:+ Tuple of (rvec, tvec), each shape (3,).+ """+ rvec, _ = cv2.Rodrigues(M[:3, :3])+ tvec = M[:3, 3]+ return rvec.ravel(), tvec.ravel()+++def select_matrices_robust(matrices: list[NDArray[np.float64]]) -> list[NDArray[np.float64]]:+ """Cluster 4x4 transformation matrices and return those in the largest cluster.++ Uses Ward hierarchical clustering on concatenated (rvec, tvec) features.+ Filters outlier transforms that don't belong to the dominant mode.++ Args:+ matrices: List of 4x4 transformation matrices.++ Returns:+ Subset of matrices belonging to the largest cluster.+ """+ if len(matrices) <= 3:+ return list(matrices)++ Ms = np.array(matrices)+ rvecs = [cv2.Rodrigues(M[:3, :3])[0].ravel() for M in Ms]+ tvecs = [M[:3, 3] for M in Ms]+ features = np.hstack([np.array(rvecs), np.array(tvecs)])++ whitened = whiten(features)+ Z = linkage(whitened, method="ward")+ n_clust = max(len(matrices) // 10, 3)+ clusters = fcluster(Z, t=n_clust, criterion="maxclust")++ cc = Counter(clusters[clusters >= 0])+ top = cc.most_common(n=1)[0][0]+ mask = clusters == top++ return [matrices[i] for i in range(len(matrices)) if mask[i]]+++def mean_transform(matrices: list[NDArray[np.float64]]) -> NDArray[np.float64]:+ """Compute mean 4x4 transformation from a list of transforms.++ Averages Rodrigues vectors and translation vectors independently,+ then reconstructs the transformation matrix.++ Args:+ matrices: Non-empty list of 4x4 transformation matrices.++ Returns:+ Mean 4x4 transformation matrix.++ Raises:+ ValueError: If the list is empty or produces NaN results.+ """+ if len(matrices) == 0:+ raise ValueError("Cannot compute mean transform from empty list")++ rvecs: list[NDArray[np.float64]] = []+ tvecs: list[NDArray[np.float64]] = []++ for i, M in enumerate(matrices):+ rvec = cv2.Rodrigues(M[:3, :3])[0].ravel()+ tvec = M[:3, 3]++ if rvec.shape != (3,) or tvec.shape != (3,):+ raise ValueError(f"Matrix {i}: invalid rvec shape {rvec.shape} or tvec shape {tvec.shape}")++ rvecs.append(rvec)+ tvecs.append(tvec)++ mean_rvec = np.mean(rvecs, axis=0)+ mean_tvec = np.mean(tvecs, axis=0)++ if np.any(np.isnan(mean_rvec)):+ raise ValueError(f"NaN in mean rvec: {mean_rvec}")+ if np.any(np.isnan(mean_tvec)):+ raise ValueError(f"NaN in mean tvec: {mean_tvec}")++ return make_M(mean_rvec, mean_tvec)+++def mean_transform_robust(+ matrices: list[NDArray[np.float64]],+ initial_estimate: NDArray[np.float64],+ error_threshold: float = 0.3,+ max_iterations: int = 5,+ convergence_threshold: float = 0.001,+) -> NDArray[np.float64]:+ """Iteratively filter outlier transforms and recompute the mean.++ At each iteration, transforms whose rotation block differs from the+ current estimate by more than ``error_threshold`` are discarded.+ If all are discarded, the best 50% by error are kept as a fallback.++ Args:+ matrices: List of 4x4 transformation matrices.+ initial_estimate: Starting approximation for comparison.+ error_threshold: Max acceptable rotation-block deviation.+ max_iterations: Maximum refinement iterations.+ convergence_threshold: Stop if change falls below this.++ Returns:+ Robustly averaged 4x4 transformation matrix.++ Raises:+ ValueError: If the input list is empty.+ """+ if len(matrices) == 0:+ raise ValueError("Cannot compute robust mean from empty list")++ current = initial_estimate++ for iteration in range(max_iterations):+ kept: list[NDArray[np.float64]] = []+ errors: list[float] = []++ for M in matrices:+ rot_error = np.max(np.abs((M - current)[:3, :3]))+ errors.append(rot_error)+ if rot_error < error_threshold:+ kept.append(M)++ if len(kept) == 0:+ sorted_indices = np.argsort(errors)+ n_keep = max(len(matrices) // 2, 3)+ kept = [matrices[i] for i in sorted_indices[:n_keep]]+ logger.warning(+ f"All matrices filtered at threshold {error_threshold}. "+ f"Using {len(kept)} best matrices as fallback."+ )++ new_mean = mean_transform(kept)+ diff = np.max(np.abs(new_mean - current))+ current = new_mean++ if diff < convergence_threshold:+ break++ return current+++def robust_average_transforms(transforms: list[NDArray[np.float64]]) -> NDArray[np.float64]:+ """Full robust averaging pipeline for a list of 4x4 transforms.++ Clusters to remove outliers, computes initial mean, then progressively+ refines with decreasing error thresholds.++ Args:+ transforms: List of 4x4 transformation matrices.++ Returns:+ Robustly averaged 4x4 transformation matrix.++ Raises:+ ValueError: If the input list is empty.+ """+ if len(transforms) == 0:+ raise ValueError("No transforms to average")++ selected = select_matrices_robust(transforms)+ current = mean_transform(selected)++ for threshold in [0.5, 0.3, 0.15, 0.1]:+ refined = mean_transform_robust(+ matrices=transforms,+ initial_estimate=current,+ error_threshold=threshold,+ max_iterations=3,+ convergence_threshold=0.001,+ )++ diff = np.max(np.abs(refined - current))+ if diff > 10.0:+ logger.warning(f"Large transform change ({diff:.2f}) at threshold {threshold}, stopping refinement")+ break++ current = refined++ return current+++def build_maximum_spanning_tree(+ connection_counts: dict[tuple[int, int], int],+ n_nodes: int,+ node_labels: list[str] | None = None,+) -> dict[int, list[int]]:+ """Build a maximum spanning tree from weighted edges via greedy Kruskal.++ Args:+ connection_counts: Mapping of (node_a, node_b) → weight for all pairs+ (both directions, i.e. (a,b) and (b,a)).+ n_nodes: Total number of nodes.+ node_labels: Human-readable labels for error messages.++ Returns:+ Adjacency list representation of the spanning tree.++ Raises:+ ValueError: If the graph cannot be connected.+ """+ if node_labels is None:+ node_labels = [str(i) for i in range(n_nodes)]++ components = {i: i for i in range(n_nodes)}+ edges = set(connection_counts.items())+ graph: dict[int, list[int]] = defaultdict(list)++ for _ in range(n_nodes - 1):+ if len(edges) == 0:+ comp_map = {node_labels[k]: v for k, v in components.items()}+ raise ValueError(+ f"Cannot build connected calibration graph. "+ f"Some cameras have no shared board observations. "+ f"Component map: {comp_map}"+ )++ (a, b), weight = max(edges, key=lambda x: x[1])+ graph[a].append(b)+ graph[b].append(a)++ match_comp = components[a]+ replace_comp = components[b]+ for k in components:+ if components[k] == match_comp:+ components[k] = replace_comp++ for e in list(edges):+ (ea, eb), _ = e+ if components[ea] == components[eb]:+ edges.discard(e)++ return dict(graph)+++def find_spanning_tree_pairs(+ graph: dict[int, list[int]],+ root: int = 0,+) -> list[tuple[int, int]]:+ """BFS from root to produce (parent, child) pairs for the spanning tree.++ Args:+ graph: Adjacency list (from ``build_maximum_spanning_tree``).+ root: Root node index.++ Returns:+ List of (parent, child) tuples in BFS order.+ """+ pairs: list[tuple[int, int]] = []+ visited: set[int] = set()+ q: queue.Queue[int] = queue.Queue()+ q.put(root)+ visited.add(root)++ while not q.empty():+ node = q.get()+ for neighbor in graph.get(node, []):+ if neighbor not in visited:+ visited.add(neighbor)+ q.put(neighbor)+ pairs.append((node, neighbor))++ return pairsdiff --git a/freemocap/core/calibration/shared/triangulator.py b/freemocap/core/calibration/shared/triangulator.pynew file mode 100644index 00000000..37393f17--- /dev/null+++ b/freemocap/core/calibration/shared/triangulator.py@@ -0,0 +1,322 @@+"""Triangulator: pure DLT triangulation from CameraModel list.++No dependency on anipose. Works directly with the Pydantic CameraModel+and CalibrationResult types from calibration_models.py.+"""++import logging++import cv2+import numpy as np+from numpy.typing import NDArray+from pydantic import BaseModel, ConfigDict, model_validator++from freemocap.core.calibration.shared.calibration_models import CameraModel, CalibrationResult++logger = logging.getLogger(__name__)+++def _undistort_points(+ points_2d: NDArray[np.float64],+ camera: CameraModel,+) -> NDArray[np.float64]:+ """Undistort 2D points using camera intrinsics. Returns normalized coordinates."""+ pts = points_2d.reshape(-1, 1, 2).astype(np.float64)+ K = camera.intrinsics.to_camera_matrix()+ dist = camera.intrinsics.to_dist_coeffs()+ undistorted = cv2.undistortPoints(pts, K, dist)+ return undistorted.reshape(-1, 2)+++def _triangulate_single_point(+ normalized_points: NDArray[np.float64],+ extrinsics_mats: NDArray[np.float64],+) -> NDArray[np.float64]:+ """Triangulate a single 3D point from undistorted+normalized 2D observations via DLT.++ Args:+ normalized_points: (N, 2) undistorted normalized coordinates for N cameras.+ extrinsics_mats: (N, 3, 4) [R|t] matrices for those N cameras.++ Returns:+ (3,) 3D point in world coordinates.+ """+ n_views = normalized_points.shape[0]+ A = np.zeros((n_views * 2, 4), dtype=np.float64)+ for i in range(n_views):+ x, y = normalized_points[i]+ P = extrinsics_mats[i]+ A[i * 2] = x * P[2] - P[0]+ A[i * 2 + 1] = y * P[2] - P[1]++ _, _, vh = np.linalg.svd(A, full_matrices=True)+ p_homogeneous = vh[-1]+ return p_homogeneous[:3] / p_homogeneous[3]+++class Triangulator(BaseModel):+ """Triangulates 2D observations into 3D using calibrated CameraModels.++ Constructed from a list of CameraModel (as produced by CalibrationResult).+ Camera ordering is determined by the order of the cameras list.+ All input data must follow this same ordering.+ """++ model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)++ cameras: list[CameraModel]++ # Precomputed arrays cached after construction+ _extrinsics_mats: NDArray[np.float64] | None = None+ _projection_mats: NDArray[np.float64] | None = None++ @model_validator(mode="after")+ def _precompute(self) -> "Triangulator":+ if len(self.cameras) < 2:+ raise ValueError(f"Triangulator requires at least 2 cameras, got {len(self.cameras)}")+ # Precompute [R|t] and P matrices for each camera+ ext = np.zeros((len(self.cameras), 3, 4), dtype=np.float64)+ proj = np.zeros((len(self.cameras), 3, 4), dtype=np.float64)+ for i, cam in enumerate(self.cameras):+ R = cam.extrinsics.rotation_matrix+ t = cam.extrinsics.translation+ ext[i, :, :3] = R+ ext[i, :, 3] = t+ proj[i] = cam.projection_matrix+ object.__setattr__(self, "_extrinsics_mats", ext)+ object.__setattr__(self, "_projection_mats", proj)+ return self++ @property+ def camera_names(self) -> list[str]:+ return [cam.name for cam in self.cameras]++ @property+ def n_cameras(self) -> int:+ return len(self.cameras)++ # =========================================================================+ # CONSTRUCTION HELPERS+ # =========================================================================++ @classmethod+ def from_calibration_result(cls, calibration: CalibrationResult) -> "Triangulator":+ """Build a triangulator using all cameras from a CalibrationResult."""+ return cls(cameras=calibration.cameras)++ @classmethod+ def from_calibration_for_cameras(+ cls,+ calibration: CalibrationResult,+ camera_ids: list[str],+ ) -> "Triangulator":+ """Build a triangulator with cameras ordered to match camera_ids.++ Each camera_id must exactly match a CameraModel.name in the calibration.+ The resulting Triangulator's camera ordering matches the camera_ids ordering.++ Raises:+ KeyError: If any camera_id is not found in the calibration.+ """+ calibration_cameras_by_name = {cam.name: cam for cam in calibration.cameras}+ ordered_cameras: list[CameraModel] = []+ for cam_id in camera_ids:+ if cam_id not in calibration_cameras_by_name:+ raise KeyError(+ f"Camera '{cam_id}' not found in calibration. "+ f"Calibration contains: {list(calibration_cameras_by_name.keys())}"+ )+ ordered_cameras.append(calibration_cameras_by_name[cam_id])+ return cls(cameras=ordered_cameras)++ @classmethod+ def from_calibration_toml(cls, path: str) -> "Triangulator":+ """Load a calibration TOML and build a triangulator from all its cameras."""+ from pathlib import Path as _Path+ result = CalibrationResult.load_anipose_toml(_Path(path))+ return cls.from_calibration_result(calibration=result)++ # =========================================================================+ # CORE TRIANGULATION+ # =========================================================================++ def triangulate_points(+ self,+ points_2d: NDArray[np.float64],+ undistort: bool = True,+ ) -> NDArray[np.float64]:+ """Triangulate 2D points to 3D via DLT.++ Args:+ points_2d: (n_cameras, n_points, 2) array of 2D pixel coordinates.+ NaN entries indicate a missing observation for that camera/point.+ undistort: If True, undistort points using camera intrinsics before+ triangulating. Set to False if points are already normalized.++ Returns:+ (n_points, 3) array of 3D world coordinates. Points with fewer than+ 2 valid observations are filled with NaN.+ """+ n_cams, n_points, _ = points_2d.shape+ if n_cams != self.n_cameras:+ raise ValueError(+ f"points_2d has {n_cams} cameras but triangulator has {self.n_cameras}"+ )++ # Undistort all points+ if undistort:+ undistorted = np.empty_like(points_2d)+ for cam_idx, cam in enumerate(self.cameras):+ undistorted[cam_idx] = _undistort_points(+ points_2d=points_2d[cam_idx],+ camera=cam,+ )+ else:+ undistorted = points_2d++ # Triangulate each point+ out = np.full((n_points, 3), np.nan, dtype=np.float64)+ for pt_idx in range(n_points):+ subp = undistorted[:, pt_idx, :]+ valid = ~np.isnan(subp[:, 0])+ if np.sum(valid) < 2:+ continue+ out[pt_idx] = _triangulate_single_point(+ normalized_points=subp[valid],+ extrinsics_mats=self._extrinsics_mats[valid],+ )++ return out++ def triangulate_dict(+ self,+ points_2d_by_camera: dict[str, NDArray[np.float64]],+ ) -> NDArray[np.float64]:+ """Triangulate from a dict of {camera_name: (n_frames, n_points, 2)}.++ Camera ordering is matched by name. Raises if a camera name is unknown.++ Returns:+ (n_frames, n_points, 3) array of triangulated 3D coordinates.+ """+ name_to_idx = {name: i for i, name in enumerate(self.camera_names)}++ # Validate camera names+ for cam_name in points_2d_by_camera:+ if cam_name not in name_to_idx:+ raise KeyError(+ f"Camera '{cam_name}' not found in triangulator. "+ f"Known cameras: {self.camera_names}"+ )++ # Determine shape from first entry+ first_array = next(iter(points_2d_by_camera.values()))+ if first_array.ndim != 3 or first_array.shape[2] != 2:+ raise ValueError(+ f"Expected arrays of shape (n_frames, n_points, 2), got {first_array.shape}"+ )+ n_frames = first_array.shape[0]+ n_points = first_array.shape[1]++ # Stack into (n_cameras, n_frames, n_points, 2) in triangulator camera order+ stacked = np.full(+ (self.n_cameras, n_frames, n_points, 2), np.nan, dtype=np.float64,+ )+ for cam_name, data in points_2d_by_camera.items():+ if data.shape != (n_frames, n_points, 2):+ raise ValueError(+ f"Camera '{cam_name}' has shape {data.shape}, "+ f"expected ({n_frames}, {n_points}, 2)"+ )+ stacked[name_to_idx[cam_name]] = data++ return self.triangulate_array(data2d=stacked)++ def triangulate_array(+ self,+ data2d: NDArray[np.float64],+ ) -> NDArray[np.float64]:+ """Triangulate from a (n_cameras, n_frames, n_points, 2) array.++ Camera ordering must match self.cameras ordering.++ Returns:+ (n_frames, n_points, 3) array.+ """+ n_cameras, n_frames, n_points, n_dims = data2d.shape+ if n_cameras != self.n_cameras:+ raise ValueError(+ f"data2d has {n_cameras} cameras but triangulator has {self.n_cameras}"+ )+ if n_dims == 3:+ data2d = data2d[..., :2]++ # Flatten frames*points, triangulate, reshape+ flat = data2d.reshape(n_cameras, -1, 2)+ triangulated_flat = self.triangulate_points(points_2d=flat)+ return triangulated_flat.reshape(n_frames, n_points, 3)++ # =========================================================================+ # REPROJECTION+ # =========================================================================++ def project(self, points_3d: NDArray[np.float64]) -> NDArray[np.float64]:+ """Project 3D points through all cameras.++ Args:+ points_3d: (n_points, 3) world coordinates.++ Returns:+ (n_cameras, n_points, 2) pixel coordinates.+ """+ n_points = points_3d.shape[0]+ out = np.empty((self.n_cameras, n_points, 2), dtype=np.float64)+ pts = points_3d.reshape(-1, 1, 3)+ for cam_idx, cam in enumerate(self.cameras):+ rvec = cam.extrinsics.rodrigues_vector+ tvec = cam.extrinsics.translation+ K = cam.intrinsics.to_camera_matrix()+ dist = cam.intrinsics.to_dist_coeffs()+ projected, _ = cv2.projectPoints(pts, rvec, tvec, K, dist)+ out[cam_idx] = projected.reshape(n_points, 2)+ return out++ def reprojection_error(+ self,+ points_3d: NDArray[np.float64],+ points_2d: NDArray[np.float64],+ ) -> NDArray[np.float64]:+ """Compute reprojection error.++ Args:+ points_3d: (n_points, 3) triangulated 3D points.+ points_2d: (n_cameras, n_points, 2) original 2D observations.++ Returns:+ (n_cameras, n_points, 2) signed reprojection error per camera per point.+ NaN where the original observation was NaN.+ """+ projected = self.project(points_3d=points_3d)+ error = points_2d - projected+ # Preserve NaN mask+ nan_mask = np.isnan(points_2d)+ error[nan_mask] = np.nan+ return error++ def mean_reprojection_error(+ self,+ points_3d: NDArray[np.float64],+ points_2d: NDArray[np.float64],+ ) -> NDArray[np.float64]:+ """Mean reprojection error per point (across cameras).++ Returns:+ (n_points,) mean Euclidean reprojection error.+ """+ errors = self.reprojection_error(points_3d=points_3d, points_2d=points_2d)+ errors_norm = np.linalg.norm(errors, axis=2) # (n_cameras, n_points)+ valid = ~np.isnan(errors_norm)+ errors_norm[~valid] = 0.0+ denom = np.sum(valid, axis=0).astype(np.float64)+ denom[denom < 1.5] = np.nan+ return np.sum(errors_norm, axis=0) / denomdiff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/__init__.py b/freemocap/core/mocap/__init__.pysimilarity index 100%rename from freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/__init__.pyrename to freemocap/core/mocap/__init__.pydiff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/mocap_helpers/__init__.py b/freemocap/core/mocap/mocap_helpers/__init__.pysimilarity index 100%rename from freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/mocap_helpers/__init__.pyrename to freemocap/core/mocap/mocap_helpers/__init__.pydiff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/mocap_helpers/charuco_model_from_observations.py b/freemocap/core/mocap/mocap_helpers/charuco_model_from_observations.pysimilarity index 67%rename from freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/mocap_helpers/charuco_model_from_observations.pyrename to freemocap/core/mocap/mocap_helpers/charuco_model_from_observations.pyindex df07de8c..c7c1b504 100644--- a/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/mocap_helpers/charuco_model_from_observations.py+++ b/freemocap/core/mocap/mocap_helpers/charuco_model_from_observations.py@@ -1,35 +1,45 @@+"""Build a charuco board 3D model from tracked observations.++Shared post-calibration step used by both anipose and pyceres paths.+Triangulates 2D charuco detections into 3D using the calibrated cameras,+then interpolates, filters, and saves the result.+"""+import loggingfrom pathlib import Path-import numpy as npfrom skellyforge.post_processing.filters.apply_filter import filter_trajectoryfrom skellyforge.post_processing.filters.filter_config import FilterConfigfrom skellyforge.post_processing.interpolation.apply_interpolation import interpolate_trajectoryfrom skellyforge.post_processing.interpolation.interpolation_config import InterpolationConfig-from skellyforge.skellymodels.models.tracking_model_info import MediapipeModelInfo, CharucoBoard5x3ModelInfofrom skellyforge.skellymodels.managers.board import Board-from skellyforge.data_models.trajectory_3d import Trajectory3d-+from skellyforge.skellymodels.models.tracking_model_info import CharucoBoard5x3ModelInfofrom skellytracker.trackers.base_tracker.base_tracker_abcs import BaseRecorderfrom skellytracker.trackers.charuco_tracker.charuco_observation import CharucoObservation-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.freemocap_anipose import \- AniposeCameraGroup-from freemocap.core.pipeline.posthoc_pipelines.posthoc_mocap_pipeline.mocap_helpers.triangulate_trajectory_array import \- TriangulationConfig, triangulate_dict+from freemocap.core.calibration.anipose_calibration.helpers.freemocap_anipose import AniposeCameraGroup+from freemocap.core.mocap.mocap_helpers.triangulate_trajectory_array import TriangulationConfig, triangulate_dictfrom freemocap.core.types.type_overloads import VideoIdString+from typing import TYPE_CHECKING++if TYPE_CHECKING:+ from skellyforge.data_models.trajectory_3d import Trajectory3d+ import numpy as nplogger = logging.getLogger(__name__)-def charuco_model_from_observations(observation_recorders: dict[VideoIdString, BaseRecorder],- output_data_folder: Path | str,- calibration_toml_path: Path | str|None,- anipose_camera_group: AniposeCameraGroup | None = None,- triangulation_config: TriangulationConfig | None = None,- interp_config: InterpolationConfig | None = None,- filter_config: FilterConfig | None = None,- ) -> Board:+def charuco_model_from_observations(+ *,+ observation_recorders: dict[VideoIdString, BaseRecorder],+ output_data_folder: Path | str,+ calibration_toml_path: Path | str | None,+ anipose_camera_group: AniposeCameraGroup | None = None,+ triangulation_config: TriangulationConfig | None = None,+ interp_config: InterpolationConfig | None = None,+ filter_config: FilterConfig | None = None,+) -> Board:+ """Triangulate, interpolate, filter charuco observations and save the 3D board model."""if triangulation_config is None:triangulation_config = TriangulationConfig()if interp_config is None:@@ -44,21 +54,19 @@ def charuco_model_from_observations(observation_recorders: dict[VideoIdString, Bif calibration_toml_path is not None:anipose_camera_group = AniposeCameraGroup.load(str(calibration_toml_path))- Path(output_data_folder).mkdir(parents=True,- exist_ok=True)+ Path(output_data_folder).mkdir(parents=True, exist_ok=True)data2d_by_video: dict[VideoIdString, np.ndarray] = {}if len(observation_recorders) == 0:raise ValueError("No observation recorders provided to process.")for video_id, recorder in observation_recorders.items():- if not all([isinstance(observation, CharucoObservation) for observation in recorder.observations]):+ if not all(isinstance(observation, CharucoObservation) for observation in recorder.observations):raise TypeError(f"Recorder for video ID {video_id} contains non-Charuco observations.")data2d_fr_id_xyc = recorder.to_array.copy()logger.info(f"Processing video ID: {video_id} with 2D data shape: {data2d_fr_id_xyc.shape}")data2d_by_video[video_id] = data2d_fr_id_xyc[..., :2]-raw_trajectory_3d: Trajectory3d = triangulate_dict(data2d_fr_mar_xy_by_camera=data2d_by_video,camera_group=anipose_camera_group,@@ -67,22 +75,20 @@ def charuco_model_from_observations(observation_recorders: dict[VideoIdString, Binterpolated_trajectory_3d: Trajectory3d = interpolate_trajectory(trajectory=raw_trajectory_3d,- config=interp_config+ config=interp_config,)filtered_trajectory_3d: Trajectory3d = filter_trajectory(trajectory=interpolated_trajectory_3d,- config=filter_config+ config=filter_config,)charuco_model = Board.from_tracked_points_numpy_array(- # name/model info are hardcoded - but ideally we'll make a some sort of config that we'll pull from to choose thesename="charuco_board_5x3",model_info=CharucoBoard5x3ModelInfo(),tracked_points_numpy_array=filtered_trajectory_3d.triangulated_data,)-charuco_model.save_out_numpy_data(output_data_folder)charuco_model.save_out_csv_data(output_data_folder)charuco_model.save_out_all_data_csv(output_data_folder)diff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/mocap_helpers/skeleton_from_mediapipe_observations.py b/freemocap/core/mocap/mocap_helpers/skeleton_from_mediapipe_observations.pysimilarity index 52%rename from freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/mocap_helpers/skeleton_from_mediapipe_observations.pyrename to freemocap/core/mocap/mocap_helpers/skeleton_from_mediapipe_observations.pyindex ba39aca4..a43b6506 100644--- a/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/mocap_helpers/skeleton_from_mediapipe_observations.py+++ b/freemocap/core/mocap/mocap_helpers/skeleton_from_mediapipe_observations.py@@ -1,3 +1,4 @@+import loggingfrom pathlib import Path@@ -11,61 +12,79 @@ from skellyforge.skellymodels.managers.human import Humanfrom skellyforge.skellymodels.models.tracking_model_info import MediapipeModelInfofrom skellytracker.trackers.base_tracker.base_tracker_abcs import BaseRecorder-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.freemocap_anipose import \- AniposeCameraGroup-from freemocap.core.pipeline.posthoc_pipelines.posthoc_mocap_pipeline.mocap_helpers.triangulate_trajectory_array import \- TriangulationConfig, triangulate_dict+from freemocap.core.calibration.shared.calibration_models import CalibrationResult+from freemocap.core.calibration.shared.triangulator import Triangulatorfrom freemocap.core.types.type_overloads import VideoIdStringlogger = logging.getLogger(__name__)-def skeleton_from_mediapipe_observation_recorders(observation_recorders:dict[VideoIdString, BaseRecorder],- path_to_calibration_toml: Path | str,- path_to_output_data_folder: Path | str,- triangulation_config: TriangulationConfig|None = None,- interp_config: InterpolationConfig|None = None,- filter_config: FilterConfig|None = None,- ) -> Human:- if triangulation_config is None:- triangulation_config = TriangulationConfig()+def skeleton_from_mediapipe_observation_recorders(+ observation_recorders: dict[VideoIdString, BaseRecorder],+ path_to_calibration_toml: Path | str,+ path_to_output_data_folder: Path | str,+ interp_config: InterpolationConfig | None = None,+ filter_config: FilterConfig | None = None,+) -> Human:+ """Triangulate mediapipe 2D observations into a 3D skeleton.++ Camera matching: observation_recorders keys (VideoIdString, i.e. camera IDs)+ are matched to calibration camera names. Each key must have an exact match+ in the calibration file's camera names.+ """if interp_config is None:interp_config = InterpolationConfig()if filter_config is None:filter_config = FilterConfig()- Path(path_to_output_data_folder).mkdir(parents=True,- exist_ok=True)+ Path(path_to_output_data_folder).mkdir(parents=True, exist_ok=True)- data2d_by_video: dict[VideoIdString, np.ndarray] = {}if len(observation_recorders) == 0:raise ValueError("No observation recorders provided to process.")+ # Extract 2D data from observation recorders+ data2d_by_camera: dict[VideoIdString, np.ndarray] = {}for video_id, recorder in observation_recorders.items():data2d_fr_id_xyc = recorder.to_array.copy()- logger.info(f"Processing video ID: {video_id} with 2D data shape: {data2d_fr_id_xyc.shape}")- data2d_by_video[video_id] = data2d_fr_id_xyc[..., :2]+ logger.info(f"Processing camera ID: {video_id} with 2D data shape: {data2d_fr_id_xyc.shape}")+ data2d_by_camera[video_id] = data2d_fr_id_xyc[..., :2]++ # Load calibration and build triangulator matched to our camera IDs+ calibration = CalibrationResult.load_anipose_toml(Path(path_to_calibration_toml))+ camera_ids = list(data2d_by_camera.keys())++ triangulator = Triangulator.from_calibration_for_cameras(+ calibration=calibration,+ camera_ids=camera_ids,+ )++ # Triangulate+ raw_3d = triangulator.triangulate_dict(points_2d_by_camera=data2d_by_camera)- camera_group=AniposeCameraGroup.load(str(path_to_calibration_toml))+ # Apply 180-degree rotation about X axis (freemocap convention: Y-down to Y-up)+ rotation_matrix = np.array([[1, 0, 0], [0, -1, 0], [0, 0, -1]])+ raw_3d = raw_3d @ rotation_matrix.T- raw_trajectory_3d: Trajectory3d = triangulate_dict(- data2d_fr_mar_xy_by_camera=data2d_by_video,- camera_group=camera_group,- config=triangulation_config,+ n_frames = raw_3d.shape[0]+ raw_trajectory_3d = Trajectory3d(+ start_frame=0,+ end_frame=n_frames,+ triangulated_data=raw_3d,+ reprojection_error=np.array([]),+ reprojection_error_by_camera=np.array([]),)interpolated_trajectory_3d: Trajectory3d = interpolate_trajectory(trajectory=raw_trajectory_3d,- config=interp_config+ config=interp_config,)filtered_trajectory_3d: Trajectory3d = filter_trajectory(trajectory=interpolated_trajectory_3d,- config=filter_config+ config=filter_config,)skeleton: Human = Human.from_tracked_points_numpy_array(- # name/model info are hardcoded - but ideally we'll make a some sort of config that we'll pull from to choose thesename="human",model_info=MediapipeModelInfo(),tracked_points_numpy_array=filtered_trajectory_3d.triangulated_data,diff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/mocap_helpers/triangulate_trajectory_array.py b/freemocap/core/mocap/mocap_helpers/triangulate_trajectory_array.pysimilarity index 60%rename from freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/mocap_helpers/triangulate_trajectory_array.pyrename to freemocap/core/mocap/mocap_helpers/triangulate_trajectory_array.pyindex 27dce683..c1104ef0 100644--- a/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/mocap_helpers/triangulate_trajectory_array.py+++ b/freemocap/core/mocap/mocap_helpers/triangulate_trajectory_array.py@@ -5,10 +5,9 @@ import numpy as npfrom pydantic import BaseModelfrom skellyforge.data_models.trajectory_3d import Observation3d, Trajectory3dfrom skellyforge.data_models.type_overloads import CameraIdString, FrameObservationsByCamera, Trajectory2dGroup+from skellytracker.trackers.base_tracker.base_tracker_abcs import BaseObservation-from skellytracker.trackers.base_tracker.base_tracker_abcs import BaseObservation-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.freemocap_anipose import \- AniposeCameraGroup+from freemocap.core.calibration.anipose_calibration.helpers.freemocap_anipose import AniposeCameraGrouplogger = logging.getLogger(__name__)@@ -46,28 +45,17 @@ def triangulate_array(data2d_flat, progress=False, kill_event=None)- if triangulated_data_flat is None:- raise ValueError("Triangulation stopped due to kill event")-- # Reshape to frames × points × xyztriangulated3d_fr_id_xyz = triangulated_data_flat.reshape(number_of_frames, number_of_tracked_points, 3)- if not calculate_reprojection_error:- return triangulated3d_fr_id_xyz, np.array([]), np.array([])- # Calculate reprojection errors- reprojection_error_full = camera_group.reprojection_error(- triangulated_data_flat, data2d_flat- )- reprojection_error_flat = camera_group.calculate_mean_reprojection_error(- reprojection_error_full+ # Calculate reprojection error+ reprojection_error_by_camera = camera_group.reprojection_error(+ triangulated3d_fr_id_xyz.reshape(-1, 3),+ data2d_flat,+ mean=False,)-- # Reshape reprojection errors- reprojection_error_by_camera = np.linalg.norm(- reprojection_error_full, axis=2- ).reshape(number_of_cameras, number_of_frames, number_of_tracked_points)+ reprojection_error_flat = np.mean(reprojection_error_by_camera, axis=0)reprojection_error = reprojection_error_flat.reshape(number_of_frames, number_of_tracked_points)@@ -111,12 +99,15 @@ def triangulate_frame_observations(frame_number: int,rotated_triangulated = rotate_by_180_deg_about_x(triangulated_data)+ # Get names from the PointCloud — structurally guaranteed to match+ # to_2d_array() row order because both read from the same object.+ first_obs = next(iter(frame_observations_by_camera.values()))+ point_names = list(first_obs.points.names)+return Observation3d(frame_number=frame_number,triangulated_data=np.squeeze(rotated_triangulated),- names=list(frame_observations_by_camera.values())[0].to_tracked_points().keys(),- # reprojection_error=reprojection_error,- # reprojection_error_by_camera=reprojection_error_by_camera,+ names=point_names,)def rotate_by_180_deg_about_x(points_3d: np.ndarray) -> np.ndarray:@@ -134,56 +125,14 @@ def triangulate_frame_groups(observations_3d = []frame_groups = dict(sorted(frame_groups.items()))for frame_number, frame_group in frame_groups.items():- observations_3d.append(triangulate_frame_observations(- frame_number, frame_group, camera_group, config- ))- return Trajectory3d.from_observations(list(frame_groups.values()))---def triangulate_trajectories(- trajectory_group: Trajectory2dGroup,- camera_group: AniposeCameraGroup,- config: TriangulationConfig,-):- # TODO: move this validation into Trajectory2dGroup creation- if len(set(trajectory.start_frame for trajectory in trajectory_group.values())) != 1:- raise ValueError(- "Input data must have the same start frame for all trajectories"- )- if len(set(trajectory.end_frame for trajectory in trajectory_group.values())) != 1:- raise ValueError(- "Input data must have the same end frame for all trajectories"+ observation_3d = triangulate_frame_observations(+ frame_number=frame_number,+ frame_observations_by_camera=frame_group,+ anipose_camera_group=camera_group,+ config=config,)- camera_group = subset_camera_names(data_dict=trajectory_group, anipose_camera_group=camera_group)- ordered_trajectory_group = preserve_camera_group_order(data_by_camera=trajectory_group, camera_group=camera_group)-- data_2d = np.stack(- [trajectory.points2d for trajectory in ordered_trajectory_group.values()],- axis=0- )-- if len(trajectory_group) != data_2d.shape[0]:- logger.error(- f"Expected {len(trajectory_group)} cameras but got {data_2d.shape[0]} cameras"- )- raise ValueError(- "Input data must have the same number of cameras as the camera group"- )-- triangulated_data, reprojection_error, reprojection_error_by_camera = triangulate_array(- data_2d, camera_group, config- )-- start_frame = list(trajectory_group.values())[0].start_frame- end_frame = list(trajectory_group.values())[0].end_frame-- return Trajectory3d(- start_frame=start_frame,- end_frame=end_frame,- triangulated_data=triangulated_data,- reprojection_error=reprojection_error,- reprojection_error_by_camera=reprojection_error_by_camera,- )+ observations_3d.append(observation_3d)+ return Trajectory3d.from_observations(observations_3d)def triangulate_dict(@@ -193,32 +142,31 @@ def triangulate_dict(start_frame: int | None = None,end_frame: int | None = None,) -> Trajectory3d:+ """Triangulate pre-stacked 2D arrays (one per camera) into a 3D trajectory."""camera_group = subset_camera_names(data_dict=data2d_fr_mar_xy_by_camera, anipose_camera_group=camera_group)- ordered_data_dict:dict[CameraIdString,object] = preserve_camera_group_order(data_by_camera=data2d_fr_mar_xy_by_camera, camera_group=camera_group)+ ordered_data_dict: dict[CameraIdString, object] = preserve_camera_group_order(+ data_by_camera=data2d_fr_mar_xy_by_camera, camera_group=camera_group+ )stacked_2d_data_list = []for camera_id, data2d_fr_mar_xy in ordered_data_dict.items():- if any([not isinstance(data2d_fr_mar_xy, np.ndarray) for data2d_fr_mar_xy in ordered_data_dict.values()]):+ if any([not isinstance(d, np.ndarray) for d in ordered_data_dict.values()]):raise TypeError("All values in data2d_fr_mar_xy_by_camera must be numpy arrays")if len(data2d_fr_mar_xy.shape) != 3:- logger.error(- f"Expected 3D array for camera {camera_id} but got array with shape {data2d_fr_mar_xy.shape}"- )raise ValueError(- "Input data arrays must have shape (frames, markers, 2)"+ f"Input data arrays must have shape (frames, markers, 2) — "+ f"got shape {data2d_fr_mar_xy.shape} for camera {camera_id}")if data2d_fr_mar_xy.shape[2] != 2:- logger.error(- f"Expected last dimension of size 2 for camera {camera_id} but got size {data2d_fr_mar_xy.shape[2]}"- )raise ValueError(- "Input data arrays must have shape (frames, markers, 2)"+ f"Input data arrays must have last dimension of size 2 — "+ f"got size {data2d_fr_mar_xy.shape[2]} for camera {camera_id}")stacked_2d_data_list.append(data2d_fr_mar_xy)- data2d_camera_fr_mar_xy = np.stack(stacked_2d_data_list,axis=0)+ data2d_camera_fr_mar_xy = np.stack(stacked_2d_data_list, axis=0)logger.info(f"shape of combined_2d_data: {data2d_camera_fr_mar_xy.shape}")triangulated_data, reprojection_error, reprojection_error_by_camera = triangulate_array(@@ -237,7 +185,19 @@ def triangulate_dict()-def subset_camera_names(data_dict: dict[CameraIdString, Any], anipose_camera_group: AniposeCameraGroup)->AniposeCameraGroup:+def triangulate_trajectories(+ trajectories_2d: Trajectory2dGroup,+ camera_group: AniposeCameraGroup,+ config: TriangulationConfig = TriangulationConfig(),+) -> Trajectory3d:+ return triangulate_frame_groups(+ frame_groups=trajectories_2d.as_frame_groups(),+ camera_group=camera_group,+ config=config,+ )+++def subset_camera_names(data_dict: dict, anipose_camera_group: AniposeCameraGroup) -> AniposeCameraGroup:valid_calibration_names = []for camera in anipose_camera_group.cameras:for key in data_dict.keys():@@ -246,25 +206,28 @@ def subset_camera_names(data_dict: dict[CameraIdString, Any], anipose_camera_grobreakif len(valid_calibration_names) != len(data_dict.keys()):raise ValueError(- "Camera names in frame group do not match camera names in camera group. Make sure calibration matches input data."+ f"Camera names in frame group do not match camera names in camera group. "+ f"Make sure calibration matches input data. "+ f"Expected: {valid_calibration_names}, got: {list(data_dict.keys())}")if len(valid_calibration_names) == len(anipose_camera_group.cameras):return anipose_camera_grouplogger.warning(- f"Frame group is missing cameras from camera group, triangulating with only cameras in frame group: {valid_calibration_names}"+ f"Frame group is missing cameras from camera group, "+ f"triangulating with only cameras in frame group: {valid_calibration_names}")return anipose_camera_group.subset_cameras_names(valid_calibration_names)-def preserve_camera_group_order(data_by_camera: dict[CameraIdString, object], camera_group: AniposeCameraGroup) -> dict[- CameraIdString, object]:+def preserve_camera_group_order(+ data_by_camera: dict[str, Any],+ camera_group: AniposeCameraGroup,+) -> dict[str, Any]:+ """Reorder the data dict to match the camera group's camera order."""ordered_data_dict = {}-for camera in camera_group.cameras:- for camrea_id, data in data_by_camera.items():- if camera.name in camrea_id:- ordered_data_dict[camrea_id] = data+ for camera_id, data in data_by_camera.items():+ if camera.name in camera_id:+ ordered_data_dict[camera_id] = databreak--- return ordered_data_dict+ return ordered_data_dict\ No newline at end of filediff --git a/freemocap/core/mocap/mocap_task.py b/freemocap/core/mocap/mocap_task.pynew file mode 100644index 00000000..060b6284--- /dev/null+++ b/freemocap/core/mocap/mocap_task.py@@ -0,0 +1,87 @@+"""+run_mocap_task: posthoc motion capture processing.++Extracted from the old PosthocMocapAggregationNode._run().+Receives collected mediapipe observations, builds skeleton via triangulation.++Called by PosthocAggregationNode after all frames are collected.+Pre-bind task_config via functools.partial when creating the pipeline.+"""+import logging+from collections.abc import Callable+from pathlib import Path++from skellycam.core.recorders.videos.recording_info import RecordingInfo+from skellytracker.trackers.base_tracker.base_tracker_abcs import BaseObservation, BaseRecorder+from skellytracker.trackers.mediapipe_tracker import MediapipeObservation++from freemocap.core.calibration.shared.calibration_paths import get_last_successful_calibration_toml_path+from freemocap.core.mocap.mocap_helpers.skeleton_from_mediapipe_observations import \+ skeleton_from_mediapipe_observation_recorders+from freemocap.core.pipeline.pipeline_configs import MocapPipelineConfig+from freemocap.core.pipeline.posthoc.video_group_helper import VideoMetadata+from freemocap.core.types.type_overloads import VideoIdString++logger = logging.getLogger(__name__)+++def run_mocap_task(+ *,+ frame_observations: list[dict[VideoIdString, BaseObservation]],+ recording_info: RecordingInfo,+ video_metadata: dict[VideoIdString, VideoMetadata],+ report_progress: Callable[[str, float], None],+ task_config: MocapPipelineConfig,+) -> None:+ """+ Run posthoc motion capture on collected mediapipe observations.++ Args:+ frame_observations: Per-frame dict of {video_id: MediapipeObservation}.+ recording_info: Recording metadata.+ video_metadata: Per-video metadata.+ report_progress: Callback for (detail, fraction) progress updates.+ task_config: Mocap-specific config (pre-bound via partial).+ """+ video_ids = list(video_metadata.keys())++ # ---- Build observation recorders ----+ report_progress("Building observation recorders", 0.1)++ observation_recorders: dict[VideoIdString, BaseRecorder] = {+ vid_id: BaseRecorder() for vid_id in video_ids+ }++ for frame_idx, frame_obs in enumerate(frame_observations):+ for vid_id, obs in frame_obs.items():+ if not isinstance(obs, MediapipeObservation):+ raise TypeError(+ f"Expected MediapipeObservation for video {vid_id} frame {frame_idx}, "+ f"got {type(obs).__name__}"+ )+ observation_recorders[vid_id].add_observation(observation=obs)++ # ---- Get calibration path ----+ calibration_toml_path = get_last_successful_calibration_toml_path()+ if calibration_toml_path is None:+ raise RuntimeError(+ "No calibration file found — cannot run mocap without calibration. "+ "Run a calibration pipeline first."+ )++ # ---- Run skeleton triangulation ----+ report_progress("Triangulating skeleton", 0.3)+ logger.info("Starting skeleton triangulation...")++ output_folder = Path(recording_info.full_recording_path) / "output_data"++ skeleton_from_mediapipe_observation_recorders(+ observation_recorders=observation_recorders,+ path_to_calibration_toml=calibration_toml_path,+ path_to_output_data_folder=output_folder,+ )++ report_progress("Mocap complete", 1.0)+ logger.info(+ f"Posthoc mocap complete! Output saved to {output_folder}"+ )diff --git a/freemocap/core/pipeline/realtime_pipeline/__init__.py b/freemocap/core/mocap/skeleton_dewiggler/__init__.pysimilarity index 100%rename from freemocap/core/pipeline/realtime_pipeline/__init__.pyrename to freemocap/core/mocap/skeleton_dewiggler/__init__.pydiff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/__init__.py b/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/__init__.pysimilarity index 100%rename from freemocap/core/pipeline/realtime_pipeline/realtime_tasks/__init__.pyrename to freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/__init__.pydiff --git a/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/bone_length_estimator.py b/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/bone_length_estimator.pynew file mode 100644index 00000000..93fb255b--- /dev/null+++ b/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/bone_length_estimator.py@@ -0,0 +1,455 @@+"""+Online bone length estimation with anthropometric priors.++Starts from standard body proportions (scaled by height) and adapts+toward observed data as confidence builds. Handles the noise-inflated+distance bias that occurs when both bone endpoints have position noise.++Key insight: adding Gaussian noise to both endpoints of a bone+systematically inflates the observed Euclidean distance (Rice distribution).+The bias is approximately (n_dims - 1) * sigma² / (2 * d), which is+negligible for long bones (~0.03cm for a 43cm thigh) but significant for+short bones (~7% for a 4cm heel). We apply a first-order correction.++Usage:+ from skeleton_config import SkeletonDefinition+ from bone_length_estimator import AnthropometricPrior, BoneLengthEstimator++ skeleton = SkeletonDefinition.mediapipe_body()+ prior = AnthropometricPrior.mediapipe_body()++ estimator = BoneLengthEstimator.create(+ skeleton=skeleton,+ prior=prior,+ height_meters=1.75,+ noise_sigma=0.008, # per-keypoint position noise (meters)+ )++ for positions in stream:+ estimator.observe(positions=positions)+ lengths = estimator.current_lengths # blended estimates+ confidence = estimator.current_confidence # per-bone 0→1++ # Wire into the filter pipeline:+ pipeline = SkeletonFilterPipeline.from_bone_lengths(+ skeleton=skeleton,+ config=filter_config,+ bone_lengths=estimator.current_lengths,+ )+"""++from collections import deque+from dataclasses import dataclass, field++import numpy as np+from pydantic import BaseModel, ConfigDict, model_validator++from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.mediapipe_skeleton_config import SkeletonDefinition+++# ============================================================+# Single Bone Estimate+# ============================================================+++@dataclass(frozen=True)+class BoneLengthEstimate:+ """Snapshot of a single bone's current length estimate."""++ bone_key: str+ prior_length: float+ raw_median: float | None+ corrected_median: float | None+ observed_iqr: float | None+ sample_count: int+ confidence: float+ blended_length: float+++# ============================================================+# Anthropometric Prior+# ============================================================+++class AnthropometricPrior(BaseModel):+ """+ Standard body proportions as bone-length-to-height ratios.++ Each ratio maps a bone key ("parent->child") to+ ``bone_length / total_height``.+ """++ model_config = ConfigDict(frozen=True)++ ratios: dict[str, float]++ @model_validator(mode="after")+ def _validate_positive(self) -> "AnthropometricPrior":+ for key, ratio in self.ratios.items():+ if ratio <= 0.0:+ raise ValueError(f"Ratio for '{key}' must be positive, got {ratio}")+ return self++ def to_bone_lengths(self, *, height_meters: float) -> dict[str, float]:+ """Scale ratios by total body height to get bone lengths in meters."""+ if height_meters <= 0.0:+ raise ValueError(f"height_meters must be positive, got {height_meters}")+ return {key: ratio * height_meters for key, ratio in self.ratios.items()}++ # --------------------------------------------------------+ # Mediapipe Body+ # --------------------------------------------------------++ @classmethod+ def mediapipe_body(cls) -> "AnthropometricPrior":+ """+ Standard adult body proportions.++ Ratios from Winter (2009) and Drillis & Contini (1966),+ expressed as bone_length / total_standing_height.+ """+ return cls(ratios={+ # Arms+ "left_shoulder->left_elbow": 0.186,+ "left_elbow->left_wrist": 0.146,+ "right_shoulder->right_elbow": 0.186,+ "right_elbow->right_wrist": 0.146,+ # Legs+ "left_hip->left_knee": 0.245,+ "left_knee->left_ankle": 0.246,+ "right_hip->right_knee": 0.245,+ "right_knee->right_ankle": 0.246,+ # Feet+ "left_ankle->left_heel": 0.024,+ "left_ankle->left_foot_index": 0.085,+ "right_ankle->right_heel": 0.024,+ "right_ankle->right_foot_index": 0.085,+ })++ # --------------------------------------------------------+ # Mediapipe Hands+ # --------------------------------------------------------++ @classmethod+ def _mediapipe_hand(cls, *, side: str) -> "AnthropometricPrior":+ """+ Standard adult hand proportions.++ Hand length ~ 0.108 * height. Finger segment ratios from+ Buryanov & Kotiuk (2010) and Garrett (1971), expressed+ as bone_length / total_standing_height.+ """+ if side not in ("left", "right"):+ raise ValueError(f"side must be 'left' or 'right', got '{side}'")++ prefix = f"{side}_hand"++ def bk(parent: str, child: str) -> str:+ return f"{prefix}_{parent}->{prefix}_{child}"++ hl = 0.108 # hand_length / height++ return cls(ratios={+ # Thumb+ bk("wrist", "thumb_cmc"): hl * 0.15,+ bk("thumb_cmc", "thumb_mcp"): hl * 0.18,+ bk("thumb_mcp", "thumb_ip"): hl * 0.17,+ bk("thumb_ip", "thumb_tip"): hl * 0.14,+ # Index+ bk("wrist", "index_finger_mcp"): hl * 0.48,+ bk("index_finger_mcp", "index_finger_pip"): hl * 0.26,+ bk("index_finger_pip", "index_finger_dip"): hl * 0.15,+ bk("index_finger_dip", "index_finger_tip"): hl * 0.12,+ # Middle+ bk("wrist", "middle_finger_mcp"): hl * 0.46,+ bk("middle_finger_mcp", "middle_finger_pip"): hl * 0.28,+ bk("middle_finger_pip", "middle_finger_dip"): hl * 0.17,+ bk("middle_finger_dip", "middle_finger_tip"): hl * 0.13,+ # Ring+ bk("wrist", "ring_finger_mcp"): hl * 0.44,+ bk("ring_finger_mcp", "ring_finger_pip"): hl * 0.26,+ bk("ring_finger_pip", "ring_finger_dip"): hl * 0.15,+ bk("ring_finger_dip", "ring_finger_tip"): hl * 0.12,+ # Pinky+ bk("wrist", "pinky_mcp"): hl * 0.42,+ bk("pinky_mcp", "pinky_pip"): hl * 0.22,+ bk("pinky_pip", "pinky_dip"): hl * 0.12,+ bk("pinky_dip", "pinky_tip"): hl * 0.10,+ })++ @classmethod+ def mediapipe_left_hand(cls) -> "AnthropometricPrior":+ return cls._mediapipe_hand(side="left")++ @classmethod+ def mediapipe_right_hand(cls) -> "AnthropometricPrior":+ return cls._mediapipe_hand(side="right")++ # --------------------------------------------------------+ # Merge+ # --------------------------------------------------------++ @classmethod+ def merge(cls, *, priors: list["AnthropometricPrior"]) -> "AnthropometricPrior":+ """Merge multiple priors. Raises on duplicate bone keys."""+ merged: dict[str, float] = {}+ for prior in priors:+ for key, ratio in prior.ratios.items():+ if key in merged:+ raise ValueError(f"Duplicate bone key '{key}' when merging priors")+ merged[key] = ratio+ return cls(ratios=merged)++ @classmethod+ def mediapipe_body_and_hands(cls) -> "AnthropometricPrior":+ """Body + both hands merged."""+ return cls.merge(priors=[+ cls.mediapipe_body(),+ cls.mediapipe_left_hand(),+ cls.mediapipe_right_hand(),+ ])+++# ============================================================+# Estimator Config+# ============================================================+++class EstimatorConfig(BaseModel):+ """Tunable parameters for bone length estimation."""++ model_config = ConfigDict(frozen=True)++ max_samples: int = 500+ min_samples_for_full_confidence: int = 100+ iqr_confidence_sensitivity: float = 10.0+++# ============================================================+# Noise Bias Correction+# ============================================================++_N_SPATIAL_DIMS: int = 3+++def _correct_noise_bias(+ *,+ raw_median: float,+ noise_sigma: float,+) -> float:+ """+ First-order correction for the noise-inflated distance bias.++ When both endpoints of a bone have i.i.d. Gaussian position noise+ with std ``noise_sigma`` per axis, the observed Euclidean distance+ follows a Rice distribution whose mean is biased upward.++ The first-order correction is:+ d_corrected ≈ d_observed - (n-1) * sigma_diff² / (2 * d_observed)+ where:+ n = number of spatial dimensions (3)+ sigma_diff² = 2 * noise_sigma² (independent noise on both endpoints)++ This is accurate when d >> sigma. For very short bones where+ d ~ sigma, the correction can overshoot, so we clamp to a minimum+ of ``noise_sigma`` (below which we have no real signal anyway).+ """+ if raw_median <= 0.0:+ return raw_median++ sigma_diff_sq = 2.0 * noise_sigma ** 2+ correction = (_N_SPATIAL_DIMS - 1) * sigma_diff_sq / (2.0 * raw_median)+ corrected = raw_median - correction++ # Don't let correction push below noise floor+ return max(corrected, noise_sigma)+++# ============================================================+# Bone Length Estimator+# ============================================================+++@dataclass+class BoneLengthEstimator:+ """+ Online bone length estimator with anthropometric priors.++ Per bone, maintains a rolling buffer of observed inter-keypoint+ distances. Blends between the anthropometric prior and the+ bias-corrected observed median based on a confidence score.++ Confidence accounts for:+ - Sample count: more data → higher confidence+ - Measurement consistency: tighter IQR → higher confidence++ Confidence formula:+ count_factor = clamp(n / min_samples, 0, 1)+ consistency_factor = 1 / (1 + sensitivity * iqr / median)+ confidence = count_factor * consistency_factor++ Blended estimate:+ length = prior * (1 - confidence) + corrected_median * confidence+ """++ skeleton: SkeletonDefinition+ config: EstimatorConfig+ prior_lengths: dict[str, float]+ noise_sigma: float+ _observations: dict[str, deque[float]] = field(init=False, repr=False)++ def __post_init__(self) -> None:+ for bone in self.skeleton.bones:+ if bone.key not in self.prior_lengths:+ raise ValueError(f"Missing prior length for bone '{bone.key}'")+ if self.prior_lengths[bone.key] <= 0.0:+ raise ValueError(+ f"Prior length must be positive for '{bone.key}', "+ f"got {self.prior_lengths[bone.key]}"+ )+ if self.noise_sigma < 0.0:+ raise ValueError(f"noise_sigma must be non-negative, got {self.noise_sigma}")++ self._observations = {+ bone.key: deque(maxlen=self.config.max_samples)+ for bone in self.skeleton.bones+ }++ @classmethod+ def create(+ cls,+ *,+ skeleton: SkeletonDefinition,+ prior: AnthropometricPrior,+ height_meters: float,+ noise_sigma: float,+ config: EstimatorConfig = EstimatorConfig(),+ ) -> "BoneLengthEstimator":+ """+ Create estimator from skeleton + anthropometric prior + height.++ Args:+ skeleton: skeleton topology (bones define what to measure).+ prior: anthropometric ratios for bone lengths.+ height_meters: subject's standing height in meters.+ noise_sigma: estimated per-keypoint position noise std (meters).+ Can be calibrated from a static capture.+ config: estimation parameters.+ """+ prior_lengths = prior.to_bone_lengths(height_meters=height_meters)++ for bone in skeleton.bones:+ if bone.key not in prior_lengths:+ raise ValueError(+ f"Anthropometric prior missing bone '{bone.key}'. "+ f"Prior covers: {sorted(prior_lengths.keys())}"+ )++ return cls(+ skeleton=skeleton,+ config=config,+ prior_lengths=prior_lengths,+ noise_sigma=noise_sigma,+ )++ def observe(self, *, positions: dict[str, np.ndarray]) -> None:+ """+ Observe one frame of keypoint positions.++ Bones where either endpoint is missing are silently skipped.+ """+ for bone in self.skeleton.bones:+ parent_pos = positions.get(bone.parent)+ child_pos = positions.get(bone.child)+ if parent_pos is None or child_pos is None:+ continue++ dist = float(np.linalg.norm(+ np.asarray(parent_pos) - np.asarray(child_pos)+ ))+ if dist <= 0.0:+ continue++ self._observations[bone.key].append(dist)++ def get_estimate(self, *, bone_key: str) -> BoneLengthEstimate:+ """Get the current blended estimate for a single bone."""+ if bone_key not in self._observations:+ raise ValueError(f"Unknown bone '{bone_key}'")++ prior_length = self.prior_lengths[bone_key]+ obs = self._observations[bone_key]+ n = len(obs)++ if n == 0:+ return BoneLengthEstimate(+ bone_key=bone_key,+ prior_length=prior_length,+ raw_median=None,+ corrected_median=None,+ observed_iqr=None,+ sample_count=0,+ confidence=0.0,+ blended_length=prior_length,+ )++ sorted_obs = np.array(sorted(obs))+ raw_median = float(np.median(sorted_obs))+ q25 = float(np.percentile(sorted_obs, 25))+ q75 = float(np.percentile(sorted_obs, 75))+ iqr = q75 - q25++ corrected_median = _correct_noise_bias(+ raw_median=raw_median,+ noise_sigma=self.noise_sigma,+ )++ # Confidence = count_factor * consistency_factor+ count_factor = min(1.0, n / self.config.min_samples_for_full_confidence)++ if raw_median > 1e-9:+ normalized_iqr = iqr / raw_median+ else:+ normalized_iqr = float("inf")++ consistency_factor = 1.0 / (+ 1.0 + self.config.iqr_confidence_sensitivity * normalized_iqr+ )++ confidence = count_factor * consistency_factor+ blended = prior_length * (1.0 - confidence) + corrected_median * confidence++ return BoneLengthEstimate(+ bone_key=bone_key,+ prior_length=prior_length,+ raw_median=raw_median,+ corrected_median=corrected_median,+ observed_iqr=iqr,+ sample_count=n,+ confidence=confidence,+ blended_length=blended,+ )++ @property+ def current_lengths(self) -> dict[str, float]:+ """Current blended bone length estimates for all bones."""+ return {+ bone.key: self.get_estimate(bone_key=bone.key).blended_length+ for bone in self.skeleton.bones+ }++ @property+ def current_confidence(self) -> dict[str, float]:+ """Current confidence (0→1) for all bones."""+ return {+ bone.key: self.get_estimate(bone_key=bone.key).confidence+ for bone in self.skeleton.bones+ }++ @property+ def all_estimates(self) -> dict[str, BoneLengthEstimate]:+ """Full estimate details for all bones."""+ return {+ bone.key: self.get_estimate(bone_key=bone.key)+ for bone in self.skeleton.bones+ }diff --git a/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/fabrik_solver.py b/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/fabrik_solver.pynew file mode 100644index 00000000..053c2e0b--- /dev/null+++ b/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/fabrik_solver.py@@ -0,0 +1,353 @@+"""+FABRIK (Forward And Backward Reaching Inverse Kinematics) solver+with full tree support including Y-splits.++Handles:+ - Linear chains (arm: shoulder → elbow → wrist)+ - Y-splits (ankle → heel + foot_index)+ - Multi-branch trees (wrist → 5 fingers)+ - Multiple disjoint trees (separate arm/leg trees)++Tree topology is decoupled from bone lengths: the FabrikTree stores+parent/child relationships and traversal order, while bone lengths+are passed to solve_tree() as a separate dict. This allows bone+lengths to be updated per-frame (e.g. from a running estimator)+without rebuilding the tree.++Algorithm (tree extension of Aristidou & Lasenby 2011):+ Forward pass (leaves → roots):+ 1. Snap each leaf to its target position+ 2. Walk inward in reverse topological order+ 3. At each node, enforce bone length toward parent+ 4. At branch points, average positions from all children+ Backward pass (roots → leaves):+ 1. Fix each root at its target position+ 2. Walk outward in topological order+ 3. At each node, enforce bone length from parent++Usage:+ tree = FabrikTree.from_skeleton(skeleton=skel)+ solved = solve_tree(targets=positions, tree=tree, bone_lengths=lengths)+"""++from collections import deque+from dataclasses import dataclass++import numpy as np++from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.mediapipe_skeleton_config import SkeletonDefinition+++# ============================================================+# Tree Data Structure+# ============================================================+++@dataclass(frozen=True)+class FabrikNode:+ """Single node in a FABRIK tree."""++ name: str+ parent_name: str | None+ children_names: tuple[str, ...]+ bone_key: str | None # "parent->child" key for bone_lengths lookup, None for roots++ @property+ def is_root(self) -> bool:+ return self.parent_name is None++ @property+ def is_leaf(self) -> bool:+ return len(self.children_names) == 0++ @property+ def is_branch(self) -> bool:+ return len(self.children_names) > 1+++@dataclass(frozen=True)+class FabrikTree:+ """+ Forest of FABRIK trees built from a SkeletonDefinition.++ Stores topology only — bone lengths are passed separately to solve_tree().+ Nodes are stored in topological order (roots first, leaves last).+ """++ nodes: dict[str, FabrikNode]+ topo_order: tuple[str, ...] # roots first → leaves last+ root_names: frozenset[str]+ leaf_names: frozenset[str]+ bone_keys: frozenset[str] # all "parent->child" keys in this tree++ @classmethod+ def from_skeleton(+ cls,+ *,+ skeleton: SkeletonDefinition,+ ) -> "FabrikTree":+ """+ Build FABRIK tree topology from skeleton bones.++ Args:+ skeleton: skeleton topology (bones define tree edges).+ """+ if not skeleton.bones:+ return cls(+ nodes={},+ topo_order=(),+ root_names=frozenset(),+ leaf_names=frozenset(),+ bone_keys=frozenset(),+ )++ # Build adjacency: parent → [children]+ children_of: dict[str, list[str]] = {}+ parent_of: dict[str, str] = {}+ bone_joints: set[str] = set()++ for bone in skeleton.bones:+ children_of.setdefault(bone.parent, []).append(bone.child)+ parent_of[bone.child] = bone.parent+ bone_joints.add(bone.parent)+ bone_joints.add(bone.child)++ # Find roots: joints in bones that have no parent in bone graph+ root_names: set[str] = set()+ for joint in bone_joints:+ if joint not in parent_of:+ root_names.add(joint)++ if not root_names:+ raise ValueError("No root joints found — bone graph may contain cycles")++ # BFS topological order from roots+ topo_order: list[str] = []+ visited: set[str] = set()+ queue: deque[str] = deque()++ for root in sorted(root_names): # sorted for determinism+ queue.append(root)+ visited.add(root)++ while queue:+ name = queue.popleft()+ topo_order.append(name)+ for child in children_of.get(name, []):+ if child in visited:+ raise ValueError(f"Cycle detected at joint '{child}'")+ visited.add(child)+ queue.append(child)++ # Build nodes+ nodes: dict[str, FabrikNode] = {}+ leaf_names: set[str] = set()+ bone_keys: set[str] = set()++ for name in topo_order:+ children = tuple(children_of.get(name, []))+ parent = parent_of.get(name)++ bone_key: str | None = None+ if parent is not None:+ bone_key = f"{parent}->{name}"+ bone_keys.add(bone_key)++ nodes[name] = FabrikNode(+ name=name,+ parent_name=parent,+ children_names=children,+ bone_key=bone_key,+ )++ if not children:+ leaf_names.add(name)++ return cls(+ nodes=nodes,+ topo_order=tuple(topo_order),+ root_names=frozenset(root_names),+ leaf_names=frozenset(leaf_names),+ bone_keys=frozenset(bone_keys),+ )++ def validate_bone_lengths(self, bone_lengths: dict[str, float]) -> None:+ """Validate that bone_lengths covers all bones in this tree with positive values."""+ for bone_key in self.bone_keys:+ if bone_key not in bone_lengths:+ raise ValueError(f"Missing bone length for '{bone_key}'")+ if bone_lengths[bone_key] <= 0.0:+ raise ValueError(+ f"Bone length must be positive for '{bone_key}', "+ f"got {bone_lengths[bone_key]}"+ )+++# ============================================================+# Tree FABRIK Solver+# ============================================================+++_FALLBACK_DIRECTION: np.ndarray = np.array([0.0, 1.0, 0.0])+++def _enforce_bone_length(+ from_pos: np.ndarray,+ to_pos: np.ndarray,+ length: float,+) -> np.ndarray:+ """Move ``to_pos`` to be exactly ``length`` away from ``from_pos``."""+ direction = to_pos - from_pos+ dist = float(np.linalg.norm(direction))+ if dist < 1e-12:+ direction = _FALLBACK_DIRECTION.copy()+ dist = 1.0+ return from_pos + (direction / dist) * length+++def solve_fabrik_tree(+ *,+ targets: dict[str, np.ndarray],+ tree: FabrikTree,+ bone_lengths: dict[str, float],+ tolerance: float = 1e-4,+ max_iterations: int = 20,+) -> dict[str, np.ndarray]:+ """+ Solve FABRIK for a tree structure with Y-splits.++ Root joints are held fixed at their target positions.+ Leaf joints are pulled toward their target positions.+ Branch points average the constraints from all children.++ Args:+ targets: target positions for all joints in the tree,+ mapping name → (3,) array.+ tree: FABRIK tree topology.+ bone_lengths: mapping "parent->child" → length in meters.+ Must cover all bones in the tree.+ tolerance: convergence threshold on leaf end-effector error.+ max_iterations: max forward/backward iterations.++ Returns:+ Solved joint positions mapping name → (3,) array.+ """+ if not tree.nodes:+ return {}++ # Validate inputs+ for name in tree.topo_order:+ if name not in targets:+ raise ValueError(f"Missing target position for joint '{name}'")++ for bone_key in tree.bone_keys:+ if bone_key not in bone_lengths:+ raise ValueError(f"Missing bone length for '{bone_key}'")++ positions: dict[str, np.ndarray] = {+ name: np.array(targets[name], dtype=np.float64)+ for name in tree.topo_order+ }++ for _ in range(max_iterations):+ # === FORWARD PASS: leaves → roots ===+ suggested: dict[str, list[np.ndarray]] = {}++ for name in reversed(tree.topo_order):+ node = tree.nodes[name]++ if node.is_leaf:+ positions[name] = np.array(targets[name], dtype=np.float64)+ elif name in suggested:+ positions[name] = np.mean(suggested[name], axis=0)++ if node.parent_name is not None:+ assert node.bone_key is not None+ length = bone_lengths[node.bone_key]+ suggested_parent = _enforce_bone_length(+ from_pos=positions[name],+ to_pos=positions[node.parent_name],+ length=length,+ )+ suggested.setdefault(node.parent_name, []).append(suggested_parent)++ # === BACKWARD PASS: roots → leaves ===+ for name in tree.topo_order:+ node = tree.nodes[name]++ if node.is_root:+ positions[name] = np.array(targets[name], dtype=np.float64)+ else:+ assert node.parent_name is not None+ assert node.bone_key is not None+ length = bone_lengths[node.bone_key]+ positions[name] = _enforce_bone_length(+ from_pos=positions[node.parent_name],+ to_pos=positions[name],+ length=length,+ )++ # === CONVERGENCE CHECK ===+ converged = True+ for leaf_name in tree.leaf_names:+ error = float(np.linalg.norm(positions[leaf_name] - targets[leaf_name]))+ if error > tolerance:+ converged = False+ break+ if converged:+ break++ return positions+++# ============================================================+# Bone Length Estimation (simple median, for offline/batch use)+# ============================================================+++def estimate_bone_lengths(+ *,+ frames: list[dict[str, np.ndarray]],+ skeleton: SkeletonDefinition,+) -> dict[str, float]:+ """+ Estimate bone lengths as median distance across calibration frames.++ For online estimation with priors, use BoneLengthEstimator instead.++ Args:+ frames: list of position dicts (one per frame),+ each mapping keypoint name → (3,) array.+ skeleton: skeleton whose bones to measure.++ Returns:+ Dict mapping "parent->child" → median bone length.+ """+ if not frames:+ raise ValueError("Need at least one frame to estimate bone lengths")++ if not skeleton.bones:+ return {}++ bone_samples: dict[str, list[float]] = {+ bone.key: [] for bone in skeleton.bones+ }++ for positions in frames:+ for bone in skeleton.bones:+ parent_pos = positions.get(bone.parent)+ child_pos = positions.get(bone.child)+ if parent_pos is None or child_pos is None:+ continue+ dist = float(np.linalg.norm(+ np.asarray(parent_pos) - np.asarray(child_pos)+ ))+ bone_samples[bone.key].append(dist)++ bone_lengths: dict[str, float] = {}+ for bone_key, samples in bone_samples.items():+ if not samples:+ raise ValueError(f"No samples found for bone '{bone_key}'")+ bone_lengths[bone_key] = float(np.median(samples))++ return bone_lengths\ No newline at end of filediff --git a/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/mediapipe_skeleton_config.py b/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/mediapipe_skeleton_config.pynew file mode 100644index 00000000..767be315--- /dev/null+++ b/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/mediapipe_skeleton_config.py@@ -0,0 +1,439 @@+"""+Skeleton topology definitions for mediapipe body, hands, and face.++Key concepts:+ - Bone: directed parent→child edge with FABRIK length constraint.+ These define the tree structure for the FABRIK solver.+ - Connection: edge for visualization (superset of bones, includes+ non-constrained edges like torso cross-braces).+ - root_joints: joints held fixed during FABRIK solving.+ - The FABRIK tree is derived from bones + root_joints.+ Y-splits (one parent, multiple children) are natural.++Factory classmethods:+ SkeletonDefinition.mediapipe_body()+ SkeletonDefinition.mediapipe_left_hand()+ SkeletonDefinition.mediapipe_right_hand()+ SkeletonDefinition.mediapipe_face()+ SkeletonDefinition.mediapipe_full()+"""++from pydantic import BaseModel, ConfigDict, model_validator+++# ============================================================+# Core Models+# ============================================================+++class Bone(BaseModel):+ """Directed parent→child edge with a FABRIK length constraint."""++ model_config = ConfigDict(frozen=True)++ parent: str+ child: str++ @property+ def key(self) -> str:+ return f"{self.parent}->{self.child}"+++class Connection(BaseModel):+ """Edge for visualization (may or may not be a FABRIK-constrained bone)."""++ model_config = ConfigDict(frozen=True)++ parent: str+ child: str+++class SkeletonDefinition(BaseModel):+ """+ Skeleton topology as bones (FABRIK-constrained tree edges),+ connections (visualization edges), and root joints.++ The FABRIK tree is implicitly defined by ``bones`` + ``root_joints``:+ each root joint is a tree root, and bones define parent→child+ directed edges. Y-splits (one parent, multiple children) are+ represented naturally — a parent appearing in multiple bones.+ """++ model_config = ConfigDict(frozen=True)++ name: str+ bones: tuple[Bone, ...]+ connections: tuple[Connection, ...]+ root_joints: frozenset[str]+ keypoint_names: frozenset[str]++ @model_validator(mode="after")+ def _validate_topology(self) -> "SkeletonDefinition":+ for bone in self.bones:+ if bone.parent not in self.keypoint_names:+ raise ValueError(f"Bone parent '{bone.parent}' not in keypoint_names")+ if bone.child not in self.keypoint_names:+ raise ValueError(f"Bone child '{bone.child}' not in keypoint_names")++ for conn in self.connections:+ if conn.parent not in self.keypoint_names:+ raise ValueError(f"Connection parent '{conn.parent}' not in keypoint_names")+ if conn.child not in self.keypoint_names:+ raise ValueError(f"Connection child '{conn.child}' not in keypoint_names")++ for root in self.root_joints:+ if root not in self.keypoint_names:+ raise ValueError(f"Root joint '{root}' not in keypoint_names")++ # No joint should have two parents (forest of trees, not DAG)+ child_parent: dict[str, str] = {}+ for bone in self.bones:+ if bone.child in child_parent:+ raise ValueError(+ f"Joint '{bone.child}' has two parents: "+ f"'{child_parent[bone.child]}' and '{bone.parent}' — "+ f"skeleton bones must form a forest"+ )+ child_parent[bone.child] = bone.parent++ return self++ @classmethod+ def _collect_keypoint_names(+ cls,+ *,+ bones: tuple[Bone, ...],+ connections: tuple[Connection, ...],+ ) -> frozenset[str]:+ names: set[str] = set()+ for bone in bones:+ names.add(bone.parent)+ names.add(bone.child)+ for conn in connections:+ names.add(conn.parent)+ names.add(conn.child)+ return frozenset(names)++ @classmethod+ def merge(cls, *, name: str, skeletons: list["SkeletonDefinition"]) -> "SkeletonDefinition":+ """Merge multiple SkeletonDefinitions into one."""+ if not skeletons:+ raise ValueError("Need at least one skeleton to merge")++ all_bones: list[Bone] = []+ all_connections: list[Connection] = []+ all_roots: set[str] = set()+ all_keypoints: set[str] = set()+ seen_bones: set[tuple[str, str]] = set()+ seen_connections: set[tuple[str, str]] = set()++ for skel in skeletons:+ for bone in skel.bones:+ key = (bone.parent, bone.child)+ if key not in seen_bones:+ seen_bones.add(key)+ all_bones.append(bone)+ for conn in skel.connections:+ key = (conn.parent, conn.child)+ if key not in seen_connections:+ seen_connections.add(key)+ all_connections.append(conn)+ all_roots.update(skel.root_joints)+ all_keypoints.update(skel.keypoint_names)++ return cls(+ name=name,+ bones=tuple(all_bones),+ connections=tuple(all_connections),+ root_joints=frozenset(all_roots),+ keypoint_names=frozenset(all_keypoints),+ )++ # ============================================================+ # Mediapipe Body+ # ============================================================++ @classmethod+ def mediapipe_body(cls) -> "SkeletonDefinition":+ """+ Mediapipe pose (33 body landmarks).++ Root joints are the 4 torso corners (shoulders + hips).+ Limb bones form FABRIK trees branching from roots.+ Ankles Y-split into heel + foot_index.+ Torso cross-braces and head edges are connections only.+ """+ bones = tuple(+ Bone(parent=p, child=c) for p, c in (+ # Left arm+ ("left_shoulder", "left_elbow"),+ ("left_elbow", "left_wrist"),+ # Right arm+ ("right_shoulder", "right_elbow"),+ ("right_elbow", "right_wrist"),+ # Left leg + foot (Y-split at ankle)+ ("left_hip", "left_knee"),+ ("left_knee", "left_ankle"),+ ("left_ankle", "left_heel"),+ ("left_ankle", "left_foot_index"),+ # Right leg + foot (Y-split at ankle)+ ("right_hip", "right_knee"),+ ("right_knee", "right_ankle"),+ ("right_ankle", "right_heel"),+ ("right_ankle", "right_foot_index"),+ )+ )++ connections = tuple(+ Connection(parent=p, child=c) for p, c in (+ # Torso+ ("left_shoulder", "right_shoulder"),+ ("left_shoulder", "left_hip"),+ ("right_shoulder", "right_hip"),+ ("left_hip", "right_hip"),+ # Arms+ ("left_shoulder", "left_elbow"),+ ("left_elbow", "left_wrist"),+ ("left_wrist", "left_pinky"),+ ("left_wrist", "left_index"),+ ("left_wrist", "left_thumb"),+ ("left_pinky", "left_index"),+ ("right_shoulder", "right_elbow"),+ ("right_elbow", "right_wrist"),+ ("right_wrist", "right_pinky"),+ ("right_wrist", "right_index"),+ ("right_wrist", "right_thumb"),+ ("right_pinky", "right_index"),+ # Legs + feet+ ("left_hip", "left_knee"),+ ("left_knee", "left_ankle"),+ ("left_ankle", "left_heel"),+ ("left_ankle", "left_foot_index"),+ ("left_heel", "left_foot_index"),+ ("right_hip", "right_knee"),+ ("right_knee", "right_ankle"),+ ("right_ankle", "right_heel"),+ ("right_ankle", "right_foot_index"),+ ("right_heel", "right_foot_index"),+ # Head+ ("nose", "left_eye_inner"),+ ("left_eye_inner", "left_eye"),+ ("left_eye", "left_eye_outer"),+ ("left_eye_outer", "left_ear"),+ ("nose", "right_eye_inner"),+ ("right_eye_inner", "right_eye"),+ ("right_eye", "right_eye_outer"),+ ("right_eye_outer", "right_ear"),+ ("mouth_left", "mouth_right"),+ )+ )++ root_joints = frozenset({+ "left_shoulder", "right_shoulder",+ "left_hip", "right_hip",+ })++ return cls(+ name="mediapipe_body",+ bones=bones,+ connections=connections,+ root_joints=root_joints,+ keypoint_names=cls._collect_keypoint_names(bones=bones, connections=connections),+ )++ # ============================================================+ # Mediapipe Hands+ # ============================================================++ @classmethod+ def _mediapipe_hand(cls, *, side: str) -> "SkeletonDefinition":+ if side not in ("left", "right"):+ raise ValueError(f"side must be 'left' or 'right', got '{side}'")++ prefix = f"{side}_hand"++ def n(landmark: str) -> str:+ return f"{prefix}_{landmark}"++ bones = tuple(+ Bone(parent=n(p), child=n(c)) for p, c in (+ # 5 fingers Y-split from wrist+ ("wrist", "thumb_cmc"),+ ("thumb_cmc", "thumb_mcp"),+ ("thumb_mcp", "thumb_ip"),+ ("thumb_ip", "thumb_tip"),+ ("wrist", "index_finger_mcp"),+ ("index_finger_mcp", "index_finger_pip"),+ ("index_finger_pip", "index_finger_dip"),+ ("index_finger_dip", "index_finger_tip"),+ ("wrist", "middle_finger_mcp"),+ ("middle_finger_mcp", "middle_finger_pip"),+ ("middle_finger_pip", "middle_finger_dip"),+ ("middle_finger_dip", "middle_finger_tip"),+ ("wrist", "ring_finger_mcp"),+ ("ring_finger_mcp", "ring_finger_pip"),+ ("ring_finger_pip", "ring_finger_dip"),+ ("ring_finger_dip", "ring_finger_tip"),+ ("wrist", "pinky_mcp"),+ ("pinky_mcp", "pinky_pip"),+ ("pinky_pip", "pinky_dip"),+ ("pinky_dip", "pinky_tip"),+ )+ )++ connections = tuple(+ Connection(parent=n(p), child=n(c)) for p, c in (+ ("wrist", "thumb_cmc"),+ ("thumb_cmc", "thumb_mcp"),+ ("thumb_mcp", "thumb_ip"),+ ("thumb_ip", "thumb_tip"),+ ("wrist", "index_finger_mcp"),+ ("index_finger_mcp", "index_finger_pip"),+ ("index_finger_pip", "index_finger_dip"),+ ("index_finger_dip", "index_finger_tip"),+ ("wrist", "middle_finger_mcp"),+ ("middle_finger_mcp", "middle_finger_pip"),+ ("middle_finger_pip", "middle_finger_dip"),+ ("middle_finger_dip", "middle_finger_tip"),+ ("wrist", "ring_finger_mcp"),+ ("ring_finger_mcp", "ring_finger_pip"),+ ("ring_finger_pip", "ring_finger_dip"),+ ("ring_finger_dip", "ring_finger_tip"),+ ("wrist", "pinky_mcp"),+ ("pinky_mcp", "pinky_pip"),+ ("pinky_pip", "pinky_dip"),+ ("pinky_dip", "pinky_tip"),+ # Palm cross-braces+ ("index_finger_mcp", "middle_finger_mcp"),+ ("middle_finger_mcp", "ring_finger_mcp"),+ ("ring_finger_mcp", "pinky_mcp"),+ )+ )++ return cls(+ name=f"mediapipe_{prefix}",+ bones=bones,+ connections=connections,+ root_joints=frozenset({n("wrist")}),+ keypoint_names=cls._collect_keypoint_names(bones=bones, connections=connections),+ )++ @classmethod+ def mediapipe_left_hand(cls) -> "SkeletonDefinition":+ """Mediapipe left hand (21 landmarks, 5 fingers Y-split from wrist)."""+ return cls._mediapipe_hand(side="left")++ @classmethod+ def mediapipe_right_hand(cls) -> "SkeletonDefinition":+ """Mediapipe right hand (21 landmarks, 5 fingers Y-split from wrist)."""+ return cls._mediapipe_hand(side="right")++ # ============================================================+ # Mediapipe Face (Contours + Irises)+ # ============================================================++ @classmethod+ def mediapipe_face(cls) -> "SkeletonDefinition":+ """+ Mediapipe face mesh contours + irises.++ No FABRIK bones — the face is rigid, all landmarks are filter-only.+ Landmark names are ``face_{index}`` matching mediapipe mesh indices.+ """+ connections = tuple(+ Connection(parent=f"face_{a}", child=f"face_{b}")+ for a, b in _FACE_CONTOUR_CONNECTIONS+ )++ return cls(+ name="mediapipe_face",+ bones=(),+ connections=connections,+ root_joints=frozenset(),+ keypoint_names=cls._collect_keypoint_names(bones=(), connections=connections),+ )++ # ============================================================+ # Full Mediapipe+ # ============================================================++ @classmethod+ def mediapipe_full(cls) -> "SkeletonDefinition":+ """All mediapipe components merged into one skeleton."""+ return cls.merge(+ name="mediapipe_full",+ skeletons=[+ cls.mediapipe_body(),+ cls.mediapipe_left_hand(),+ cls.mediapipe_right_hand(),+ cls.mediapipe_face(),+ ],+ )+++# ============================================================+# Face Mesh Contour + Iris Connection Data+# (from mediapipe.python.solutions.face_mesh_connections)+# ============================================================++_FACE_OVAL_CONNECTIONS: tuple[tuple[int, int], ...] = (+ (10, 338), (338, 297), (297, 332), (332, 284), (284, 251),+ (251, 389), (389, 356), (356, 454), (454, 323), (323, 361),+ (361, 288), (288, 397), (397, 365), (365, 379), (379, 378),+ (378, 400), (400, 377), (377, 152), (152, 148), (148, 176),+ (176, 149), (149, 150), (150, 136), (136, 172), (172, 58),+ (58, 132), (132, 93), (93, 234), (234, 127), (127, 162),+ (162, 21), (21, 54), (54, 103), (103, 67), (67, 109), (109, 10),+)++_LIPS_CONNECTIONS: tuple[tuple[int, int], ...] = (+ (61, 185), (185, 40), (40, 39), (39, 37), (37, 0),+ (0, 267), (267, 269), (269, 270), (270, 409), (409, 291),+ (61, 146), (146, 91), (91, 181), (181, 84), (84, 17),+ (17, 314), (314, 405), (405, 321), (321, 375), (375, 291),+ (78, 191), (191, 80), (80, 81), (81, 82), (82, 13),+ (13, 312), (312, 311), (311, 310), (310, 415), (415, 308),+ (78, 95), (95, 88), (88, 178), (178, 87), (87, 14),+ (14, 317), (317, 402), (402, 318), (318, 324), (324, 308),+)++_LEFT_EYE_CONNECTIONS: tuple[tuple[int, int], ...] = (+ (263, 249), (249, 390), (390, 373), (373, 374), (374, 380),+ (380, 381), (381, 382), (382, 362), (362, 466), (466, 388),+ (388, 387), (387, 386), (386, 385), (385, 384), (384, 398), (398, 263),+)++_RIGHT_EYE_CONNECTIONS: tuple[tuple[int, int], ...] = (+ (33, 7), (7, 163), (163, 144), (144, 145), (145, 153),+ (153, 154), (154, 155), (155, 133), (133, 246), (246, 161),+ (161, 160), (160, 159), (159, 158), (158, 157), (157, 173), (173, 33),+)++_LEFT_EYEBROW_CONNECTIONS: tuple[tuple[int, int], ...] = (+ (276, 283), (283, 282), (282, 295), (295, 285),+ (300, 293), (293, 334), (334, 296), (296, 336),+)++_RIGHT_EYEBROW_CONNECTIONS: tuple[tuple[int, int], ...] = (+ (46, 53), (53, 52), (52, 65), (65, 55),+ (70, 63), (63, 105), (105, 66), (66, 107),+)++_LEFT_IRIS_CONNECTIONS: tuple[tuple[int, int], ...] = (+ (468, 469), (469, 470), (470, 471), (471, 472),+)++_RIGHT_IRIS_CONNECTIONS: tuple[tuple[int, int], ...] = (+ (473, 474), (474, 475), (475, 476), (476, 477),+)++_FACE_CONTOUR_CONNECTIONS: tuple[tuple[int, int], ...] = (+ *_FACE_OVAL_CONNECTIONS,+ *_LIPS_CONNECTIONS,+ *_LEFT_EYE_CONNECTIONS,+ *_RIGHT_EYE_CONNECTIONS,+ *_LEFT_EYEBROW_CONNECTIONS,+ *_RIGHT_EYEBROW_CONNECTIONS,+ *_LEFT_IRIS_CONNECTIONS,+ *_RIGHT_IRIS_CONNECTIONS,+)diff --git a/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/one_euro_filter.py b/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/one_euro_filter.pynew file mode 100644index 00000000..2d4c42dd--- /dev/null+++ b/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/one_euro_filter.py@@ -0,0 +1,174 @@+"""+One Euro Filter for real-time signal smoothing.++Adaptive low-pass filter that adjusts its cutoff frequency based on+the speed of the signal. Slow movements get heavy smoothing (low cutoff),+fast movements get light smoothing (high cutoff, low lag).++Includes a `predict()` method for extrapolating position when observations+are temporarily missing. Prediction uses the stored filtered velocity,+decaying it each step so the extrapolation slows to a stop rather than+drifting forever. Internal state (t_prev, x_prev, dx_prev) is updated+during prediction so that when real observations resume, the filter+transitions smoothly.++Reference:+ Casiez, Roussel, Vogel (2012)+ "1€ Filter: A Simple Speed-based Low-pass Filter for Noisy Input in+ Interactive Systems"+ https://cristal.univ-lille.fr/~casiez/1euro/++Usage:+ filter_3d = OneEuroFilter3D(t0=0.0, x0=initial_position,+ min_cutoff=0.004, beta=0.7)+ for t, raw_pos in stream:+ if raw_pos is not None:+ smooth_pos = filter_3d(t=t, x=raw_pos)+ else:+ smooth_pos = filter_3d.predict(t=t, velocity_decay=0.75)+"""++import math++import numpy as np+++def _smoothing_factor(t_e: float, cutoff: float) -> float:+ r = 2.0 * math.pi * cutoff * t_e+ return r / (r + 1.0)+++def _exponential_smoothing(a: float, x: float, x_prev: float) -> float:+ return a * x + (1.0 - a) * x_prev+++class OneEuroFilter1D:+ """One Euro low-pass filter for a single scalar signal."""++ __slots__ = ("min_cutoff", "beta", "d_cutoff", "x_prev", "dx_prev", "t_prev")++ def __init__(+ self,+ *,+ t0: float,+ x0: float,+ dx0: float = 0.0,+ min_cutoff: float = 1.0,+ beta: float = 0.0,+ d_cutoff: float = 1.0,+ ) -> None:+ self.min_cutoff: float = min_cutoff+ self.beta: float = beta+ self.d_cutoff: float = d_cutoff+ self.x_prev: float = x0+ self.dx_prev: float = dx0+ self.t_prev: float = t0++ def __call__(self, *, t: float, x: float) -> float:+ """Return filtered value. ``t`` must be strictly increasing."""+ t_e = t - self.t_prev+ if t_e <= 0.0:+ raise ValueError(+ f"Time must be strictly increasing: "+ f"t_prev={self.t_prev}, t={t}, dt={t_e}"+ )++ # Filtered derivative+ a_d = _smoothing_factor(t_e, self.d_cutoff)+ dx = (x - self.x_prev) / t_e+ dx_hat = _exponential_smoothing(a_d, dx, self.dx_prev)++ # Adaptive cutoff+ cutoff = self.min_cutoff + self.beta * abs(dx_hat)+ a = _smoothing_factor(t_e, cutoff)+ x_hat = _exponential_smoothing(a, x, self.x_prev)++ self.x_prev = x_hat+ self.dx_prev = dx_hat+ self.t_prev = t+ return x_hat++ def predict(self, *, t: float, velocity_decay: float) -> float:+ """Extrapolate position using the stored filtered velocity.++ Advances internal state so subsequent calls (real or predicted)+ see correct time deltas. Decays the velocity by ``velocity_decay``+ each call so predictions slow to a stop.++ Args:+ t: timestamp in seconds (must be strictly after t_prev).+ velocity_decay: multiplier applied to dx_prev after extrapolation.+ 0.0 = freeze immediately, 1.0 = constant velocity,+ typical ~0.7-0.85 for graceful deceleration.++ Returns:+ Predicted position.+ """+ t_e = t - self.t_prev+ if t_e <= 0.0:+ raise ValueError(+ f"Time must be strictly increasing: "+ f"t_prev={self.t_prev}, t={t}, dt={t_e}"+ )++ x_predicted = self.x_prev + self.dx_prev * t_e++ self.x_prev = x_predicted+ self.dx_prev = self.dx_prev * velocity_decay+ self.t_prev = t+ return x_predicted+++class OneEuroFilter3D:+ """One Euro filter for a 3D point (filters x, y, z independently)."""++ __slots__ = ("_filters",)++ def __init__(+ self,+ *,+ t0: float,+ x0: np.ndarray,+ min_cutoff: float = 1.0,+ beta: float = 0.0,+ d_cutoff: float = 1.0,+ ) -> None:+ if x0.shape != (3,):+ raise ValueError(f"Expected shape (3,), got {x0.shape}")+ self._filters: tuple[OneEuroFilter1D, ...] = tuple(+ OneEuroFilter1D(+ t0=t0,+ x0=float(x0[i]),+ min_cutoff=min_cutoff,+ beta=beta,+ d_cutoff=d_cutoff,+ )+ for i in range(3)+ )++ def __call__(self, *, t: float, x: np.ndarray) -> np.ndarray:+ """Return filtered 3D position. ``t`` must be strictly increasing."""+ if x.shape != (3,):+ raise ValueError(f"Expected shape (3,), got {x.shape}")+ return np.array([+ self._filters[i](t=t, x=float(x[i]))+ for i in range(3)+ ])++ def predict(self, *, t: float, velocity_decay: float) -> np.ndarray:+ """Extrapolate 3D position using stored filtered velocities.++ See OneEuroFilter1D.predict() for details on state advancement+ and velocity decay.++ Args:+ t: timestamp in seconds (must be strictly after t_prev).+ velocity_decay: per-axis velocity decay multiplier (0..1).++ Returns:+ Predicted (3,) position array.+ """+ return np.array([+ self._filters[i].predict(t=t, velocity_decay=velocity_decay)+ for i in range(3)+ ])diff --git a/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/realtime_point_gate.py b/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/realtime_point_gate.pynew file mode 100644index 00000000..c39e6c6e--- /dev/null+++ b/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/realtime_point_gate.py@@ -0,0 +1,135 @@+"""+RealtimePointGate: velocity-based rejection of garbage 3D points.++Tracks per-landmark accepted positions across frames. If a point jumps+further than max_velocity * dt between frames, the last accepted position+is held (returned in place of the rejected observation). Only accepted+points update the stored reference position, so a single garbage spike+doesn't shift the reference and cause cascading rejections.++A staleness timeout prevents permanent lockout: if a point has been+rejected for too many consecutive frames, the gate resets that point+and accepts the next observation unconditionally.++The gate always returns positions for every input point — rejected points+get their last-accepted position substituted. The `held_names` field on+`GateResult` tells the caller which points are held vs. freshly accepted.+"""++import logging+from dataclasses import dataclass++import numpy as np+from numpy.typing import NDArray++logger = logging.getLogger(__name__)+++@dataclass(frozen=True)+class GateResult:+ """Result from the point gate: positions for all input points plus metadata."""++ # All points — accepted points have fresh positions, rejected points+ # have their last-accepted position substituted.+ positions: dict[str, NDArray[np.float64]]++ # Names of points whose positions are held (i.e. were rejected this frame).+ held_names: frozenset[str]+++class RealtimePointGate:+ """Rejects 3D points whose frame-to-frame velocity exceeds a threshold.++ Rejected points are not dropped — instead, their last-accepted position+ is returned. This prevents blinking/flickering in the output.+ """++ def __init__(+ self,+ *,+ max_velocity_m_per_s: float,+ max_rejected_streak: int,+ ) -> None:+ self._max_velocity: float = max_velocity_m_per_s+ self._max_rejected_streak: int = max_rejected_streak+ self._accepted_positions: dict[str, NDArray[np.float64]] = {}+ self._previous_t: float | None = None+ self._rejected_streak: dict[str, int] = {}++ def gate(+ self,+ *,+ t: float,+ points: dict[str, NDArray[np.float64]],+ ) -> GateResult:+ """Return positions for all input points, holding last-accepted for rejected ones.++ Args:+ t: timestamp in seconds (must be strictly increasing).+ points: raw triangulated positions, mapping name -> (3,) array.++ Returns:+ GateResult with positions for every input point and the set of held names.+ """+ if self._previous_t is None:+ # First frame — accept everything, store state+ self._accepted_positions = {+ name: pos.copy() for name, pos in points.items()+ }+ self._previous_t = t+ self._rejected_streak = {name: 0 for name in points}+ return GateResult(+ positions=dict(points),+ held_names=frozenset(),+ )++ dt = t - self._previous_t+ if dt <= 0.0:+ raise ValueError(+ f"Time must be strictly increasing: "+ f"prev={self._previous_t}, t={t}, dt={dt}"+ )++ result_positions: dict[str, NDArray[np.float64]] = {}+ held: set[str] = set()++ for name, pos in points.items():+ if name not in self._accepted_positions:+ # Never-before-seen point — accept unconditionally+ result_positions[name] = pos+ self._accepted_positions[name] = pos.copy()+ self._rejected_streak[name] = 0+ continue++ streak = self._rejected_streak.get(name, 0)+ if streak >= self._max_rejected_streak:+ # Staleness timeout — accept unconditionally to prevent lockout+ result_positions[name] = pos+ self._accepted_positions[name] = pos.copy()+ self._rejected_streak[name] = 0+ continue++ distance = float(np.linalg.norm(pos - self._accepted_positions[name]))+ velocity = distance / dt++ if velocity <= self._max_velocity:+ result_positions[name] = pos+ self._accepted_positions[name] = pos.copy()+ self._rejected_streak[name] = 0+ else:+ # Rejected — return held position, do NOT update reference+ result_positions[name] = self._accepted_positions[name].copy()+ self._rejected_streak[name] = streak + 1+ held.add(name)++ self._previous_t = t+ return GateResult(+ positions=result_positions,+ held_names=frozenset(held),+ )++ def reset(self) -> None:+ """Clear all state. Call when calibration changes."""+ self._accepted_positions.clear()+ self._previous_t = None+ self._rejected_streak.clear()diff --git a/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/rigid_body_estimator.py b/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/rigid_body_estimator.pynew file mode 100644index 00000000..8d5f5e9e--- /dev/null+++ b/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/rigid_body_estimator.py@@ -0,0 +1,190 @@+"""+Rigid body segment estimation from skeleton keypoint positions.++Computes a 6-DOF pose (position + orientation) and length for each bone+segment, treating each bone as a cylinder with:+ - Origin at the parent joint+ - Local +Z axis pointing from parent toward child+ - Roll pinned to zero via a world-up vector constraint+ - Length from the current bone length estimate++The zero-roll constraint uses a look-at construction:+ 1. Z = normalize(child - parent) # bone direction+ 2. X = normalize(cross(world_up, Z)) # sideways+ 3. Y = cross(Z, X) # completes right-handed frame+ 4. Rotation matrix [X | Y | Z] → quaternion++When the bone is nearly parallel to world_up, a fallback up vector is+used to prevent degeneracy.++Usage:+ from rigid_body_estimator import estimate_rigid_bodies, RigidBodyPose++ poses: dict[str, RigidBodyPose] = estimate_rigid_bodies(+ positions=filtered_keypoint_positions,+ skeleton=skeleton_definition,+ bone_lengths=current_bone_lengths,+ )+ # poses["left_shoulder->left_elbow"].position → (x, y, z) at shoulder+ # poses["left_shoulder->left_elbow"].orientation → (w, x, y, z) quaternion+ # poses["left_shoulder->left_elbow"].length → float meters+"""++import numpy as np+from pydantic import BaseModel, ConfigDict++from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.mediapipe_skeleton_config import SkeletonDefinition+++# World-up vector for zero-roll constraint (Y-up, matching freemocap convention).+_WORLD_UP: np.ndarray = np.array([0.0, 1.0, 0.0])++# Fallback up vector when bone direction is nearly parallel to world-up.+_FALLBACK_UP: np.ndarray = np.array([0.0, 0.0, 1.0])++# Dot product threshold: if abs(dot(bone_dir, world_up)) exceeds this,+# the bone is nearly vertical and we switch to the fallback up vector.+_PARALLEL_THRESHOLD: float = 0.999+++class RigidBodyPose(BaseModel):+ """Pose of a single rigid body segment (bone).++ All fields use plain Python types so model_dump() produces clean JSON.+ """++ model_config = ConfigDict(frozen=True)++ bone_key: str+ position: tuple[float, float, float]+ orientation: tuple[float, float, float, float] # [w, x, y, z] quaternion+ length: float+++def _rotation_matrix_to_quaternion(r: np.ndarray) -> tuple[float, float, float, float]:+ """Convert a 3x3 rotation matrix to a unit quaternion (w, x, y, z).++ Uses Shepperd's method for numerical stability across all rotations.+ """+ trace = r[0, 0] + r[1, 1] + r[2, 2]++ if trace > 0.0:+ s = 2.0 * np.sqrt(trace + 1.0)+ w = 0.25 * s+ x = (r[2, 1] - r[1, 2]) / s+ y = (r[0, 2] - r[2, 0]) / s+ z = (r[1, 0] - r[0, 1]) / s+ elif r[0, 0] > r[1, 1] and r[0, 0] > r[2, 2]:+ s = 2.0 * np.sqrt(1.0 + r[0, 0] - r[1, 1] - r[2, 2])+ w = (r[2, 1] - r[1, 2]) / s+ x = 0.25 * s+ y = (r[0, 1] + r[1, 0]) / s+ z = (r[0, 2] + r[2, 0]) / s+ elif r[1, 1] > r[2, 2]:+ s = 2.0 * np.sqrt(1.0 + r[1, 1] - r[0, 0] - r[2, 2])+ w = (r[0, 2] - r[2, 0]) / s+ x = (r[0, 1] + r[1, 0]) / s+ y = 0.25 * s+ z = (r[1, 2] + r[2, 1]) / s+ else:+ s = 2.0 * np.sqrt(1.0 + r[2, 2] - r[0, 0] - r[1, 1])+ w = (r[1, 0] - r[0, 1]) / s+ x = (r[0, 2] + r[2, 0]) / s+ y = (r[1, 2] + r[2, 1]) / s+ z = 0.25 * s++ q = np.array([w, x, y, z])+ q = q / np.linalg.norm(q)+ if q[0] < 0.0:+ q = -q+ return (float(q[0]), float(q[1]), float(q[2]), float(q[3]))+++def _look_at_rotation(direction: np.ndarray) -> np.ndarray:+ """Build a rotation matrix with +Z along ``direction`` and roll pinned to zero.++ Args:+ direction: (3,) unit vector pointing from parent to child.++ Returns:+ (3, 3) rotation matrix whose columns are [X, Y, Z] of the local frame.+ """+ z_axis = direction++ # Choose up vector, falling back if bone is nearly vertical+ if abs(float(np.dot(z_axis, _WORLD_UP))) > _PARALLEL_THRESHOLD:+ up = _FALLBACK_UP.copy()+ else:+ up = _WORLD_UP.copy()++ x_axis = np.cross(up, z_axis)+ x_norm = float(np.linalg.norm(x_axis))+ if x_norm < 1e-12:+ x_axis = np.array([1.0, 0.0, 0.0])+ y_axis = np.cross(z_axis, x_axis)+ y_norm = float(np.linalg.norm(y_axis))+ if y_norm < 1e-12:+ return np.eye(3)+ y_axis = y_axis / y_norm+ x_axis = np.cross(y_axis, z_axis)+ else:+ x_axis = x_axis / x_norm++ y_axis = np.cross(z_axis, x_axis)++ rotation = np.column_stack([x_axis, y_axis, z_axis])+ return rotation+++def estimate_rigid_bodies(+ *,+ positions: dict[str, np.ndarray],+ skeleton: SkeletonDefinition,+ bone_lengths: dict[str, float],+) -> dict[str, RigidBodyPose]:+ """Compute rigid body poses for all bone segments with both endpoints present.++ Bones whose parent or child keypoint is missing from ``positions`` are+ silently skipped — only bones with both joints present get a pose.++ Args:+ positions: keypoint positions, mapping name → (3,) array.+ skeleton: skeleton topology defining bone parent→child pairs.+ bone_lengths: mapping "parent->child" → length in meters.++ Returns:+ Dict mapping bone key ("parent->child") → RigidBodyPose.+ """+ poses: dict[str, RigidBodyPose] = {}++ for bone in skeleton.bones:+ parent_pos = positions.get(bone.parent)+ child_pos = positions.get(bone.child)++ if parent_pos is None or child_pos is None:+ continue++ parent_f64 = np.asarray(parent_pos, dtype=np.float64)+ child_f64 = np.asarray(child_pos, dtype=np.float64)++ direction = child_f64 - parent_f64+ dist = float(np.linalg.norm(direction))++ if dist < 1e-12:+ continue++ direction_unit = direction / dist++ rotation = _look_at_rotation(direction=direction_unit)+ quaternion = _rotation_matrix_to_quaternion(rotation)++ length = bone_lengths.get(bone.key, dist)++ poses[bone.key] = RigidBodyPose(+ bone_key=bone.key,+ position=(float(parent_f64[0]), float(parent_f64[1]), float(parent_f64[2])),+ orientation=quaternion,+ length=length,+ )++ return posesdiff --git a/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/skeleton_filter_pipeline.py b/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/skeleton_filter_pipeline.pynew file mode 100644index 00000000..e5da17ce--- /dev/null+++ b/freemocap/core/mocap/skeleton_dewiggler/dewiggling_methods/skeleton_filter_pipeline.py@@ -0,0 +1,199 @@+"""+Skeleton filtering pipeline: One Euro Filter → Tree FABRIK.++Pipeline (per frame):+ 1. Per-keypoint One Euro filtering (removes high-frequency jitter)+ 2. Tree FABRIK solving (enforces bone length constraints, handles Y-splits)++Keypoints not in any FABRIK tree are returned filter-only (e.g. face landmarks,+torso anchors, head keypoints).++Usage:+ from skeleton_config import SkeletonDefinition+ from skeleton_filter_pipeline import FilterConfig, SkeletonFilterPipeline++ skeleton = SkeletonDefinition.mediapipe_body()+ config = FilterConfig(min_cutoff=0.004, beta=0.7)++ # From calibration frames:+ pipeline = SkeletonFilterPipeline.from_calibration(+ skeleton=skeleton,+ config=config,+ calibration_frames=my_cal_frames,+ )++ # Or with pre-computed bone lengths:+ pipeline = SkeletonFilterPipeline.from_bone_lengths(+ skeleton=skeleton,+ config=config,+ bone_lengths=my_bone_lengths,+ )++ for t, raw_positions in stream:+ clean = pipeline.process_frame(t=t, positions=raw_positions)+"""++from dataclasses import dataclass, field++import numpy as np+from pydantic import BaseModel, ConfigDict++from fabrik_solver import FabrikTree, estimate_bone_lengths, solve_fabrik_tree+from one_euro_filter import OneEuroFilter3D+from mediapipe_skeleton_config import SkeletonDefinition+++class FilterConfig(BaseModel):+ """Tunable parameters for the filtering pipeline."""++ model_config = ConfigDict(frozen=True)++ # One Euro Filter params+ min_cutoff: float = 0.004+ beta: float = 0.7+ d_cutoff: float = 1.0++ # FABRIK params+ fabrik_tolerance: float = 1e-4+ fabrik_max_iterations: int = 20+++@dataclass+class SkeletonFilterPipeline:+ """+ Frame-by-frame skeleton filtering pipeline.++ Step 1: One Euro filter on every keypoint (jitter removal).+ Step 2: Tree FABRIK on the skeleton's bone tree (bone length+ enforcement, including Y-splits like ankle→heel+foot_index+ or wrist→5 fingers).++ Keypoints not belonging to any FABRIK tree (face landmarks, torso+ anchors, head keypoints) are returned filter-only.+ """++ skeleton: SkeletonDefinition+ config: FilterConfig+ bone_lengths: dict[str, float]+ fabrik_tree: FabrikTree = field(repr=False)+ _filters: dict[str, OneEuroFilter3D] = field(+ default_factory=dict, init=False, repr=False,+ )+ _initialized: bool = field(default=False, init=False, repr=False)++ def __post_init__(self) -> None:+ self.fabrik_tree.validate_bone_lengths(self.bone_lengths)++ @classmethod+ def from_calibration(+ cls,+ *,+ skeleton: SkeletonDefinition,+ config: FilterConfig,+ calibration_frames: list[dict[str, np.ndarray]],+ ) -> "SkeletonFilterPipeline":+ """+ Create pipeline from skeleton + calibration data.++ Bone lengths are estimated as median across calibration frames.+ """+ bone_lengths = estimate_bone_lengths(+ frames=calibration_frames,+ skeleton=skeleton,+ )+ fabrik_tree = FabrikTree.from_skeleton(skeleton=skeleton)+ return cls(+ skeleton=skeleton,+ config=config,+ bone_lengths=bone_lengths,+ fabrik_tree=fabrik_tree,+ )++ @classmethod+ def from_bone_lengths(+ cls,+ *,+ skeleton: SkeletonDefinition,+ config: FilterConfig,+ bone_lengths: dict[str, float],+ ) -> "SkeletonFilterPipeline":+ """Create pipeline with pre-computed bone lengths."""+ fabrik_tree = FabrikTree.from_skeleton(skeleton=skeleton)+ return cls(+ skeleton=skeleton,+ config=config,+ bone_lengths=bone_lengths,+ fabrik_tree=fabrik_tree,+ )++ def _initialize_filters(self, *, t: float, positions: dict[str, np.ndarray]) -> None:+ for name, pos in positions.items():+ self._filters[name] = OneEuroFilter3D(+ t0=t,+ x0=np.asarray(pos, dtype=np.float64),+ min_cutoff=self.config.min_cutoff,+ beta=self.config.beta,+ d_cutoff=self.config.d_cutoff,+ )+ self._initialized = True++ def process_frame(+ self,+ *,+ t: float,+ positions: dict[str, np.ndarray],+ ) -> dict[str, np.ndarray]:+ """+ Process one frame of raw keypoint positions.++ Args:+ t: timestamp in seconds (must be strictly increasing).+ positions: raw keypoint positions, mapping name → (3,) array.++ Returns:+ Filtered + bone-length-constrained positions.+ """+ if not self._initialized:+ self._initialize_filters(t=t, positions=positions)+ return {+ name: np.array(pos, dtype=np.float64)+ for name, pos in positions.items()+ }++ # --- Step 1: One Euro filter every keypoint ---+ filtered: dict[str, np.ndarray] = {}+ for name, pos in positions.items():+ if name not in self._filters:+ raise ValueError(+ f"Keypoint '{name}' was not present in the first frame"+ )+ filtered[name] = self._filters[name](+ t=t,+ x=np.asarray(pos, dtype=np.float64),+ )++ # --- Step 2: Tree FABRIK ---+ if self.fabrik_tree.nodes:+ fabrik_targets: dict[str, np.ndarray] = {+ name: filtered[name]+ for name in self.fabrik_tree.topo_order+ }++ solved = solve_fabrik_tree(+ targets=fabrik_targets,+ tree=self.fabrik_tree,+ bone_lengths=self.bone_lengths,+ tolerance=self.config.fabrik_tolerance,+ max_iterations=self.config.fabrik_max_iterations,+ )++ result: dict[str, np.ndarray] = {}+ for name, pos in filtered.items():+ if name in solved:+ result[name] = solved[name]+ else:+ result[name] = pos+ else:+ result = filtered++ return result\ No newline at end of filediff --git a/freemocap/core/mocap/skeleton_dewiggler/realtime_skeleton_filter.py b/freemocap/core/mocap/skeleton_dewiggler/realtime_skeleton_filter.pynew file mode 100644index 00000000..df161014--- /dev/null+++ b/freemocap/core/mocap/skeleton_dewiggler/realtime_skeleton_filter.py@@ -0,0 +1,315 @@+"""+Realtime skeleton filter: One Euro + FABRIK with running bone length estimation.++Purpose-built for the realtime pipeline where:+ - Bone lengths are unknown at startup and estimated online+ - Keypoints may be partially missing on any given frame+ - Calibration can change mid-session (requiring a full reset)+ - Timestamps come from real wall-clock time, not uniform FPS++Pipeline (per frame):+ 1. Feed raw 3D positions to BoneLengthEstimator (refines bone lengths)+ 2. Per-keypoint One Euro filtering (jitter removal)+ - Present keypoints: normal filter update+ - Missing keypoints: extrapolate via filter's stored velocity+ (decaying each frame so prediction slows to a stop)+ 3. Tree FABRIK solving with latest bone lengths (constraint enforcement)++Keypoints not in any FABRIK tree are returned filter-only.+Missing keypoints are predicted for up to `max_prediction_frames` consecutive+frames, keeping the skeleton complete and FABRIK running during brief dropouts.++Usage:+ filt = RealtimeSkeletonFilter.create(+ skeleton=SkeletonDefinition.mediapipe_body(),+ prior=AnthropometricPrior.mediapipe_body(),+ config=RealtimeFilterConfig(),+ )++ for t, raw_3d_points in triangulated_stream:+ result = filt.process_frame(t=t, positions=raw_3d_points)+ # result.positions: all keypoints (observed + predicted)+ # result.predicted_names: which ones are extrapolated+"""++import logging+from dataclasses import dataclass, field++import numpy as np+from pydantic import BaseModel++from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.bone_length_estimator import EstimatorConfig, \+ BoneLengthEstimator, AnthropometricPrior+from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.fabrik_solver import FabrikTree, solve_fabrik_tree+from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.mediapipe_skeleton_config import SkeletonDefinition+from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.one_euro_filter import OneEuroFilter3D++logger = logging.getLogger(__name__)+++@dataclass(frozen=True)+class FilterResult:+ """Result from the skeleton filter: positions plus prediction metadata."""++ # All keypoint positions — both freshly filtered and predicted from previous frames.+ positions: dict[str, np.ndarray]++ # Names of keypoints whose positions are predicted (not observed this frame).+ predicted_names: frozenset[str]+++class RealtimeFilterConfig(BaseModel):+ """Tunable parameters for the realtime filtering pipeline."""++ # One Euro Filter params+ # min_cutoff: minimum cutoff frequency (Hz). Lower = more smoothing, higher = more responsive.+ min_cutoff: float = 0.005+ # beta: speed coefficient. Higher = less lag during fast motion, but more jitter at rest.+ beta: float = 0.3+ # d_cutoff: cutoff frequency for the derivative (speed estimate) filter.+ d_cutoff: float = 1.0++ # FABRIK params+ fabrik_tolerance: float = 1e-4+ fabrik_max_iterations: int = 20++ # Bone length estimation params+ # height_meters: assumed subject height, used to scale anthropometric bone length priors.+ height_meters: float = 1.75+ # noise_sigma: expected measurement noise (meters). Higher = trust raw measurements less.+ noise_sigma: float = 0.015+ estimator_config: EstimatorConfig = EstimatorConfig()++ # Reprojection error gate: reject triangulated points whose mean+ # reprojection error across cameras exceeds this threshold (pixels).+ # Higher = more permissive (keeps noisier triangulations).+ max_reprojection_error_px: float = 60.0++ # Velocity gate: reject points that jump faster than this (meters/second).+ # Human body parts rarely exceed ~15 m/s even during fast movements,+ # but noisy triangulation can produce brief spikes. Keep generous to+ # avoid rejecting real fast motions.+ max_velocity_m_per_s: float = 50.0++ # Velocity gate: after this many consecutive rejections, accept+ # unconditionally to prevent permanent lockout. Lower = recover faster.+ max_rejected_streak: int = 5++ # Prediction: how many consecutive frames to extrapolate a missing keypoint+ # using the One Euro filter's stored velocity before dropping it. Prevents+ # blinking during brief tracking dropouts. Set to 0 to disable prediction.+ max_prediction_frames: int = 15++ # Prediction: velocity decay per predicted frame. Each prediction step+ # multiplies the stored velocity by this factor, so extrapolation+ # decelerates to a stop. 0.0 = freeze, 1.0 = constant velocity.+ prediction_velocity_decay: float = 0.75+++@dataclass+class RealtimeSkeletonFilter:+ """+ Frame-by-frame realtime skeleton filter with online bone length estimation.++ Handles partial keypoint data gracefully: keypoints missing from a frame+ are extrapolated using the One Euro filter's stored velocity for up to+ `max_prediction_frames` consecutive frames. The velocity decays each+ prediction step so the extrapolation slows to a stop.++ This keeps the skeleton complete during brief tracking dropouts, allowing+ FABRIK to keep running and preventing blinking in the output.++ Bone lengths are estimated online from observed inter-keypoint distances+ and blended with an anthropometric prior. The FABRIK solver uses the+ latest blended bone lengths each frame.++ FABRIK runs when all joints in the tree are present (including predicted).+ """++ skeleton: SkeletonDefinition+ config: RealtimeFilterConfig+ bone_estimator: BoneLengthEstimator+ fabrik_tree: FabrikTree = field(repr=False)+ _filters: dict[str, OneEuroFilter3D] = field(+ default_factory=dict, init=False, repr=False,+ )+ # Tracks how many consecutive frames each keypoint has been predicted.+ # Reset to 0 when a real observation arrives.+ _consecutive_predictions: dict[str, int] = field(+ default_factory=dict, init=False, repr=False,+ )+ # All keypoint names we've ever seen (so we know what to try predicting).+ _known_keypoints: set[str] = field(+ default_factory=set, init=False, repr=False,+ )++ @classmethod+ def create(+ cls,+ *,+ skeleton: SkeletonDefinition,+ prior: AnthropometricPrior,+ config: RealtimeFilterConfig,+ ) -> "RealtimeSkeletonFilter":+ estimator = BoneLengthEstimator.create(+ skeleton=skeleton,+ prior=prior,+ height_meters=config.height_meters,+ noise_sigma=config.noise_sigma,+ config=config.estimator_config,+ )+ fabrik_tree = FabrikTree.from_skeleton(skeleton=skeleton)+ return cls(+ skeleton=skeleton,+ config=config,+ bone_estimator=estimator,+ fabrik_tree=fabrik_tree,+ )++ def reset(self) -> None:+ """Reset all filter state. Call when calibration changes."""+ self._filters.clear()+ self._consecutive_predictions.clear()+ self._known_keypoints.clear()+ # Re-create the estimator to clear observation history+ # (prior lengths are preserved via the estimator's create path)+ self.bone_estimator = BoneLengthEstimator.create(+ skeleton=self.skeleton,+ prior=AnthropometricPrior(+ ratios={+ bone_key: length / self.config.height_meters+ for bone_key, length in self.bone_estimator.prior_lengths.items()+ },+ ),+ height_meters=self.config.height_meters,+ noise_sigma=self.config.noise_sigma,+ config=self.config.estimator_config,+ )++ def process_frame(+ self,+ *,+ t: float,+ positions: dict[str, np.ndarray],+ ) -> FilterResult:+ """+ Process one frame of triangulated 3D keypoint positions.++ Args:+ t: timestamp in seconds (must be strictly increasing across calls).+ positions: raw triangulated positions, mapping name -> (3,) array.+ May be a subset of skeleton keypoints.++ Returns:+ FilterResult with filtered+constrained positions for all keypoints+ (including predicted ones) and the set of predicted keypoint names.+ """+ if not positions and not self._known_keypoints:+ return FilterResult(positions={}, predicted_names=frozenset())++ # --- Step 0: Feed the bone length estimator (only real observations) ---+ if positions:+ self.bone_estimator.observe(positions=positions)++ # --- Step 1: One Euro filter each present keypoint ---+ filtered: dict[str, np.ndarray] = {}+ predicted_names: set[str] = set()++ for name, pos in positions.items():+ pos_f64 = np.asarray(pos, dtype=np.float64)+ if pos_f64.shape != (3,):+ raise ValueError(+ f"Expected shape (3,) for keypoint '{name}', got {pos_f64.shape}"+ )++ if name not in self._filters:+ # First time seeing this keypoint — initialize filter, return raw+ self._filters[name] = OneEuroFilter3D(+ t0=t,+ x0=pos_f64,+ min_cutoff=self.config.min_cutoff,+ beta=self.config.beta,+ d_cutoff=self.config.d_cutoff,+ )+ filtered[name] = pos_f64+ else:+ filtered[name] = self._filters[name](t=t, x=pos_f64)++ self._known_keypoints.add(name)+ self._consecutive_predictions[name] = 0++ # --- Step 1b: Predict missing keypoints using filter velocity ---+ if self.config.max_prediction_frames > 0:+ for name in self._known_keypoints:+ if name in filtered:+ continue # already have fresh data+ if name not in self._filters:+ continue # no filter to predict from++ streak = self._consecutive_predictions.get(name, 0)+ if streak >= self.config.max_prediction_frames:+ continue # exhausted prediction budget, drop this keypoint++ filtered[name] = self._filters[name].predict(+ t=t,+ velocity_decay=self.config.prediction_velocity_decay,+ )+ self._consecutive_predictions[name] = streak + 1+ predicted_names.add(name)++ # --- Step 2: Tree FABRIK with latest bone lengths ---+ if not self.fabrik_tree.nodes or not filtered:+ return FilterResult(+ positions=filtered,+ predicted_names=frozenset(predicted_names),+ )++ # Check if all FABRIK tree joints are present (including predicted)+ all_tree_joints_present = all(+ name in filtered for name in self.fabrik_tree.topo_order+ )++ if not all_tree_joints_present:+ # Can't run FABRIK with missing joints — return filter-only + predicted+ return FilterResult(+ positions=filtered,+ predicted_names=frozenset(predicted_names),+ )++ bone_lengths = self.bone_estimator.current_lengths++ fabrik_targets: dict[str, np.ndarray] = {+ name: filtered[name]+ for name in self.fabrik_tree.topo_order+ }++ solved = solve_fabrik_tree(+ targets=fabrik_targets,+ tree=self.fabrik_tree,+ bone_lengths=bone_lengths,+ tolerance=self.config.fabrik_tolerance,+ max_iterations=self.config.fabrik_max_iterations,+ )++ # Merge: FABRIK-solved joints override, non-tree joints keep filter-only+ result: dict[str, np.ndarray] = {}+ for name, pos in filtered.items():+ if name in solved:+ result[name] = solved[name]+ else:+ result[name] = pos++ return FilterResult(+ positions=result,+ predicted_names=frozenset(predicted_names),+ )++ @property+ def current_bone_lengths(self) -> dict[str, float]:+ """Current blended bone length estimates."""+ return self.bone_estimator.current_lengths++ @property+ def current_confidence(self) -> dict[str, float]:+ """Current bone length estimation confidence (0->1) per bone."""+ return self.bone_estimator.current_confidencediff --git a/freemocap/core/mocap/skeleton_dewiggler/run_pipeline.py b/freemocap/core/mocap/skeleton_dewiggler/run_pipeline.pynew file mode 100644index 00000000..7095d8e0--- /dev/null+++ b/freemocap/core/mocap/skeleton_dewiggler/run_pipeline.py@@ -0,0 +1,198 @@+"""+Run the skeleton filter pipeline on a (frames, keypoints, 3) numpy array.++Expects:+ skeleton_fr_name_xyz: np.ndarray with shape (frame_count, keypoint_count, 3)+ marker_names: list[str] with length keypoint_count++Produces:+ filtered_fr_name_xyz: np.ndarray with same shape, filtered + bone-constrained+"""++import numpy as np++from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.bone_length_estimator import AnthropometricPrior, BoneLengthEstimator, EstimatorConfig+from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.mediapipe_skeleton_config import SkeletonDefinition+from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.skeleton_filter_pipeline import FilterConfig, SkeletonFilterPipeline+++def run_pipeline(+ *,+ skeleton_fr_name_xyz: np.ndarray,+ marker_names: list[str],+ skeleton: SkeletonDefinition,+ prior: AnthropometricPrior,+ height_meters: float,+ noise_sigma: float = 0.008,+ fps: float = 30.0,+ filter_config: FilterConfig = FilterConfig(),+ estimator_config: EstimatorConfig = EstimatorConfig(),+ calibration_frame_count: int = 100,+) -> np.ndarray:+ """+ Run One Euro → FABRIK pipeline on a skeleton array.++ Args:+ skeleton_fr_name_xyz: (frame_count, keypoint_count, 3) raw positions.+ marker_names: keypoint names, length must match axis 1.+ skeleton: skeleton topology definition.+ prior: anthropometric prior for bone length estimation.+ height_meters: subject standing height in meters.+ noise_sigma: per-keypoint position noise std in meters.+ fps: frame rate in Hz (used to generate timestamps).+ filter_config: One Euro + FABRIK tuning parameters.+ estimator_config: bone length estimator parameters.+ calibration_frame_count: how many initial frames to use for+ bone length estimation before starting+ the filter pipeline.++ Returns:+ (frame_count, keypoint_count, 3) filtered + constrained positions.+ """+ frame_count, keypoint_count, n_dims = skeleton_fr_name_xyz.shape+ if n_dims != 3:+ raise ValueError(f"Expected 3 dimensions, got {n_dims}")+ if len(marker_names) != keypoint_count:+ raise ValueError(+ f"marker_names length ({len(marker_names)}) != "+ f"keypoint axis size ({keypoint_count})"+ )+ if calibration_frame_count > frame_count:+ raise ValueError(+ f"calibration_frame_count ({calibration_frame_count}) > "+ f"frame_count ({frame_count})"+ )+ if fps <= 0.0:+ raise ValueError(f"fps must be positive, got {fps}")++ name_to_idx: dict[str, int] = {name: i for i, name in enumerate(marker_names)}++ def frame_to_dict(frame_idx: int) -> dict[str, np.ndarray]:+ return {+ name: skeleton_fr_name_xyz[frame_idx, idx].copy()+ for name, idx in name_to_idx.items()+ }++ # --- Phase 1: Estimate bone lengths from initial frames ---+ estimator = BoneLengthEstimator.create(+ skeleton=skeleton,+ prior=prior,+ height_meters=height_meters,+ noise_sigma=noise_sigma,+ config=estimator_config,+ )++ for i in range(calibration_frame_count):+ estimator.observe(positions=frame_to_dict(i))++ bone_lengths = estimator.current_lengths+ print(f"Bone lengths estimated from {calibration_frame_count} calibration frames:")+ for bone_key, length in sorted(bone_lengths.items()):+ est = estimator.get_estimate(bone_key=bone_key)+ print(f" {bone_key:45s} = {length*100:6.2f} cm (confidence={est.confidence:.2f})")++ # --- Phase 2: Build pipeline ---+ pipeline = SkeletonFilterPipeline.from_bone_lengths(+ skeleton=skeleton,+ config=filter_config,+ bone_lengths=bone_lengths,+ )++ # --- Phase 3: Process all frames ---+ output = np.empty_like(skeleton_fr_name_xyz)++ for i in range(frame_count):+ t = (i + 1) / fps+ positions = frame_to_dict(i)+ filtered = pipeline.process_frame(t=t, positions=positions)++ # Also keep feeding the estimator (it keeps refining)+ estimator.observe(positions=positions)++ for name, idx in name_to_idx.items():+ if name in filtered:+ output[i, idx] = filtered[name]+ else:+ output[i, idx] = skeleton_fr_name_xyz[i, idx]++ print(f"Processed {frame_count} frames")+ return output+++# ============================================================+# Example usage+# ============================================================++if __name__ == "__main__":+ # --- Synthetic test data ---+ np.random.seed(42)++ skeleton = SkeletonDefinition.mediapipe_body()+ prior = AnthropometricPrior.mediapipe_body()++ marker_names = [+ "left_shoulder", "right_shoulder", "left_hip", "right_hip",+ "left_elbow", "right_elbow", "left_wrist", "right_wrist",+ "left_knee", "right_knee", "left_ankle", "right_ankle",+ "left_heel", "right_heel", "left_foot_index", "right_foot_index",+ "nose", "left_eye_inner", "left_eye", "left_eye_outer", "left_ear",+ "right_eye_inner", "right_eye", "right_eye_outer", "right_ear",+ "mouth_left", "mouth_right",+ "left_pinky", "left_index", "left_thumb",+ "right_pinky", "right_index", "right_thumb",+ ]++ frame_count = 300+ keypoint_count = len(marker_names)++ # Ground truth positions for a 1.70m person+ true_positions = {+ "left_shoulder": [-0.18, 0, 1.42], "right_shoulder": [0.18, 0, 1.42],+ "left_hip": [-0.09, 0, 0.95], "right_hip": [0.09, 0, 0.95],+ "left_elbow": [-0.38, 0, 1.22], "right_elbow": [0.38, 0, 1.22],+ "left_wrist": [-0.50, 0, 1.05], "right_wrist": [0.50, 0, 1.05],+ "left_knee": [-0.09, 0, 0.53], "right_knee": [0.09, 0, 0.53],+ "left_ankle": [-0.09, 0, 0.04], "right_ankle": [0.09, 0, 0.04],+ "left_heel": [-0.09, -0.04, 0.0], "right_heel": [0.09, -0.04, 0.0],+ "left_foot_index": [-0.09, 0.12, 0.0], "right_foot_index": [0.09, 0.12, 0.0],+ "nose": [0, 0, 1.68],+ "left_eye_inner": [-0.02, 0, 1.70], "left_eye": [-0.03, 0, 1.70],+ "left_eye_outer": [-0.04, 0, 1.70], "left_ear": [-0.07, 0, 1.69],+ "right_eye_inner": [0.02, 0, 1.70], "right_eye": [0.03, 0, 1.70],+ "right_eye_outer": [0.04, 0, 1.70], "right_ear": [0.07, 0, 1.69],+ "mouth_left": [-0.02, 0, 1.65], "mouth_right": [0.02, 0, 1.65],+ "left_pinky": [-0.52, 0, 1.03], "left_index": [-0.51, 0, 1.02],+ "left_thumb": [-0.49, 0.02, 1.04],+ "right_pinky": [0.52, 0, 1.03], "right_index": [0.51, 0, 1.02],+ "right_thumb": [0.49, 0.02, 1.04],+ }++ # Build noisy array+ name_to_idx = {name: i for i, name in enumerate(marker_names)}+ skeleton_fr_name_xyz = np.zeros((frame_count, keypoint_count, 3))+ for frame in range(frame_count):+ for name, idx in name_to_idx.items():+ base = np.array(true_positions.get(name, [0, 0, 0]), dtype=np.float64)+ skeleton_fr_name_xyz[frame, idx] = base + np.random.normal(scale=0.01, size=3)++ # Run+ filtered = run_pipeline(+ skeleton_fr_name_xyz=skeleton_fr_name_xyz,+ marker_names=marker_names,+ skeleton=skeleton,+ prior=prior,+ height_meters=1.75, # slightly wrong guess+ noise_sigma=0.008,+ fps=30.0,+ calibration_frame_count=100,+ )++ # Verify output shape+ assert filtered.shape == skeleton_fr_name_xyz.shape+ print(f"\nOutput shape: {filtered.shape}")++ # Compare noise levels: std of frame-to-frame jitter+ raw_jitter = np.mean(np.std(np.diff(skeleton_fr_name_xyz, axis=0), axis=0))+ filtered_jitter = np.mean(np.std(np.diff(filtered, axis=0), axis=0))+ print(f"Mean frame-to-frame jitter std: raw={raw_jitter*1000:.2f}mm → filtered={filtered_jitter*1000:.2f}mm")+ print(f"Jitter reduction: {(1 - filtered_jitter/raw_jitter)*100:.0f}%")\ No newline at end of filediff --git a/freemocap/core/mocap/skeleton_dewiggler/vmc_sender.py b/freemocap/core/mocap/skeleton_dewiggler/vmc_sender.pynew file mode 100644index 00000000..992cf8f3--- /dev/null+++ b/freemocap/core/mocap/skeleton_dewiggler/vmc_sender.py@@ -0,0 +1,175 @@+"""+VMC (Virtual Motion Capture) protocol sender.++Broadcasts rigid body segment poses over OSC/UDP using the VMC protocol,+enabling real-time streaming to VTuber apps (VSeeFace, VMagicMirror),+game engines (Unity, Unreal), and other VMC-compatible receivers.++Protocol reference:+ https://protocol.vmc.info/english++VMC bone transforms are sent as:+ /VMC/Ext/Bone/Pos <name> <px> <py> <pz> <qx> <qy> <qz> <qw>++The sender maps freemocap's mediapipe bone keys ("parent->child") to+VRM humanoid bone names ("LeftUpperArm", "RightLowerLeg", etc.).++Coordinate system conversion:+ freemocap: right-handed, Y-up (after the 180° X rotation)+ VMC/Unity: left-handed, Y-up+ Conversion: negate X position and negate X/Z quaternion components.++Usage:+ sender = VMCSender(host="127.0.0.1", port=39539)+ sender.send(rigid_body_poses)+ sender.close()+"""++import logging+import socket+import struct++from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.rigid_body_estimator import RigidBodyPose++logger = logging.getLogger(__name__)+++# ---------------------------------------------------------------------------+# Mediapipe bone key → VRM humanoid bone name mapping+# ---------------------------------------------------------------------------++MEDIAPIPE_TO_VRM: dict[str, str] = {+ # Arms+ "left_shoulder->left_elbow": "LeftUpperArm",+ "left_elbow->left_wrist": "LeftLowerArm",+ "right_shoulder->right_elbow": "RightUpperArm",+ "right_elbow->right_wrist": "RightLowerArm",+ # Legs+ "left_hip->left_knee": "LeftUpperLeg",+ "left_knee->left_ankle": "LeftLowerLeg",+ "right_hip->right_knee": "RightUpperLeg",+ "right_knee->right_ankle": "RightLowerLeg",+ # Feet+ "left_ankle->left_foot_index": "LeftFoot",+ "left_ankle->left_heel": "LeftToes",+ "right_ankle->right_foot_index": "RightFoot",+ "right_ankle->right_heel": "RightToes",+}+++# ---------------------------------------------------------------------------+# Minimal OSC message builder (avoids dependency on python-osc)+# ---------------------------------------------------------------------------+++def _osc_string(s: str) -> bytes:+ """Encode a string as an OSC string (null-terminated, padded to 4 bytes)."""+ encoded = s.encode("utf-8") + b"\x00"+ # Pad to multiple of 4 bytes+ padding = (4 - len(encoded) % 4) % 4+ return encoded + b"\x00" * padding+++def _osc_float(f: float) -> bytes:+ """Encode a float as an OSC float32."""+ return struct.pack(">f", f)+++def _build_bone_message(+ bone_name: str,+ px: float,+ py: float,+ pz: float,+ qx: float,+ qy: float,+ qz: float,+ qw: float,+) -> bytes:+ """Build a single /VMC/Ext/Bone/Pos OSC message."""+ address = _osc_string("/VMC/Ext/Bone/Pos")+ type_tag = _osc_string(",sfffffff")+ payload = (+ _osc_string(bone_name)+ + _osc_float(px)+ + _osc_float(py)+ + _osc_float(pz)+ + _osc_float(qx)+ + _osc_float(qy)+ + _osc_float(qz)+ + _osc_float(qw)+ )+ return address + type_tag + payload+++def _build_bundle(messages: list[bytes], timetag: int = 1) -> bytes:+ """Build an OSC bundle containing multiple messages."""+ header = _osc_string("#bundle")+ time_bytes = struct.pack(">Q", timetag) # NTP "immediately"+ elements = b""+ for msg in messages:+ elements += struct.pack(">I", len(msg)) + msg+ return header + time_bytes + elements+++# ---------------------------------------------------------------------------+# VMC Sender+# ---------------------------------------------------------------------------+++class VMCSender:+ """Broadcasts rigid body poses over VMC (OSC/UDP).++ Converts freemocap's right-handed Y-up coordinates to VMC/Unity's+ left-handed Y-up coordinates by negating X position and X/Z quaternion+ components.+ """++ def __init__(self, *, host: str, port: int) -> None:+ self._host: str = host+ self._port: int = port+ self._socket: socket.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)+ self._socket.setblocking(False)+ logger.info(f"VMCSender initialized: {host}:{port}")++ def send(self, rigid_body_poses: dict[str, RigidBodyPose]) -> None:+ """Send all mappable rigid body poses as a VMC OSC bundle.++ Bones without a VRM mapping are silently skipped.+ """+ messages: list[bytes] = []++ for bone_key, pose in rigid_body_poses.items():+ vrm_name = MEDIAPIPE_TO_VRM.get(bone_key)+ if vrm_name is None:+ continue++ px, py, pz = pose.position+ qw, qx, qy, qz = pose.orientation++ # Right-handed → left-handed conversion: negate X pos and X/Z quat+ msg = _build_bone_message(+ bone_name=vrm_name,+ px=-px,+ py=py,+ pz=pz,+ qx=-qx,+ qy=qy,+ qz=-qz,+ qw=qw,+ )+ messages.append(msg)++ if not messages:+ return++ bundle = _build_bundle(messages)+ try:+ self._socket.sendto(bundle, (self._host, self._port))+ except OSError as e:+ # UDP send failures are non-fatal (receiver might not be running)+ logger.debug(f"VMC send failed: {e}")++ def close(self) -> None:+ """Close the UDP socket."""+ self._socket.close()+ logger.info(f"VMCSender closed: {self._host}:{self._port}")diff --git a/freemocap/core/pipeline/base_node.py b/freemocap/core/pipeline/base_node.pynew file mode 100644index 00000000..d4734035--- /dev/null+++ b/freemocap/core/pipeline/base_node.py@@ -0,0 +1,112 @@+"""+BaseNode: abstract base for all pipeline nodes (realtime and posthoc).++Encapsulates the common lifecycle pattern shared by every node:+ - A `shutdown_self_flag` (per-node shutdown signal)+ - A `worker` (ManagedWorker wrapping the child process)+ - `start()` / `shutdown()` / `is_alive` lifecycle methods++Subclasses implement a `@classmethod create()` factory that calls+`_create_worker()` to build the ManagedWorker, and a `@staticmethod _run()`+that contains the child-side logic. The `_run()` method receives the+`shutdown_self_flag` as a kwarg and should poll it alongside `ipc.should_continue`+in its main loop.++Error escalation policy (enforced by subclasses, not the base):+ - Posthoc nodes: on exception, call `ipc.shutdown_pipeline()` (pipeline-local)+ - Realtime nodes: on exception, call `ipc.kill_everything()` (app-level)+"""+import logging+import multiprocessing+import sys+import time+from collections.abc import Callable+from dataclasses import dataclass, field+from typing import Optional, ClassVar++from skellycam.core.ipc.process_management.managed_worker import ManagedWorker+from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry++logger = logging.getLogger(__name__)++# On Windows, multiprocessing.spawn causes each child process to+# re-import the full module tree. Spawning many children simultaneously+# creates a file-locking race (PermissionError) because Windows holds+# brief exclusive locks during file reads, and antivirus real-time+# scanning amplifies the contention. Staggering spawns lets each child+# finish its import phase before the next one starts.+_SPAWN_STAGGER_SECONDS: ClassVar[float] = 0.25 if sys.platform == "win32" else 0.0++@dataclass+class BaseNode:+ """+ Base class for all pipeline worker nodes.++ Every node owns a ManagedWorker and a per-node shutdown flag.+ The common lifecycle (start / shutdown / is_alive) is implemented here+ so subclasses only need to define `create()` and `_run()`.+ """++ shutdown_self_flag: multiprocessing.Value = field(repr=False)+ worker: ManagedWorker = field(repr=False)++ @property+ def is_alive(self) -> bool:+ return self.worker.is_alive()++ def start(self) -> None:+ """Start the child process. Raises if already started."""+ if self.worker.is_alive():+ raise RuntimeError(+ f"{type(self).__name__} worker '{self.worker.name}' is already running"+ )++ if _SPAWN_STAGGER_SECONDS > 0:+ time.sleep(_SPAWN_STAGGER_SECONDS)+ self.worker.start()+ logger.debug(f"{type(self).__name__} worker '{self.worker.name}' started")++ def shutdown(self) -> None:+ """+ Signal the node to stop, then escalate through SIGTERM → SIGKILL.++ Sets the per-node shutdown flag first (so the child's main loop can+ exit cleanly), then delegates to ManagedWorker.terminate_gracefully()+ for escalating force.+ """+ self.shutdown_self_flag.value = True+ self.worker._intentionally_terminated = True+ if self.worker.is_alive():+ logger.debug(f"Shutting down {type(self).__name__} worker '{self.worker.name}'")+ self.worker.terminate_gracefully()+ else:+ self.worker._reap()++ @staticmethod+ def _create_worker(+ *,+ target: Callable[..., None],+ name: str,+ worker_registry: WorkerRegistry,+ log_queue: Optional[multiprocessing.Queue],+ kwargs: dict,+ ) -> tuple[multiprocessing.Value, ManagedWorker]:+ """+ Convenience helper for subclass `create()` methods.++ Creates a shutdown_self_flag + ManagedWorker pair with consistent+ setup. The shutdown_self_flag is automatically injected into kwargs+ so the child _run() receives it.++ Returns:+ (shutdown_self_flag, worker) tuple for passing to the dataclass constructor.+ """+ shutdown_self_flag: multiprocessing.Value = multiprocessing.Value('b', False)+ kwargs["shutdown_self_flag"] = shutdown_self_flag+ worker = worker_registry.create_worker(+ target=target,+ name=name,+ log_queue=log_queue,+ kwargs=kwargs,+ )+ return shutdown_self_flag, worker\ No newline at end of filediff --git a/freemocap/core/pipeline/frontend_payload.py b/freemocap/core/pipeline/frontend_payload.pydeleted file mode 100644index a8823219..00000000--- a/freemocap/core/pipeline/frontend_payload.py+++ /dev/null@@ -1,74 +0,0 @@-import logging--from pydantic import BaseModel, ConfigDict-from skellycam.core.types.type_overloads import CameraIdString--from freemocap.core.image_overlay.charuco_overlay_data import CharucoOverlayData-from freemocap.core.image_overlay.mediapipe_overlay_data import MediapipeOverlayData-from freemocap.core.types.type_overloads import TrackedPointNameString-from freemocap.pubsub.pubsub_topics import AggregationNodeOutputMessage-from skellyforge.data_models.trajectory_3d import Point3d--logger = logging.getLogger(__name__)--# Union type for all possible overlay data types-ObservationOverlayData = CharucoOverlayData | MediapipeOverlayData---class FrontendPayload(BaseModel):- """Complete payload for frontend visualization"""- model_config = ConfigDict(- arbitrary_types_allowed=True,- validate_assignment=False- )-- frame_number: int- # Now supports multiple observation types- observation_overlays: dict[CameraIdString, ObservationOverlayData]- tracked_points3d: dict[TrackedPointNameString, Point3d] = {}-- @classmethod- def from_aggregation_output(- cls,- aggregation_output: AggregationNodeOutputMessage,- ) -> "FrontendPayload":- """Create frontend payload from aggregation node output"""-- # Combine all observation types into single dict- observation_overlays: dict[CameraIdString, ObservationOverlayData] = {}-- # Add charuco overlays if present- if hasattr(aggregation_output, 'charuco_overlay_data'):- observation_overlays.update(aggregation_output.charuco_overlay_data)-- # Add mediapipe overlays if present- if hasattr(aggregation_output, 'mediapipe_overlay_data'):- observation_overlays.update(aggregation_output.mediapipe_overlay_data)-- # Add other overlay types as they're implemented- # if hasattr(aggregation_output, 'rtmpose_overlay_data'):- # observation_overlays.update(aggregation_output.rtmpose_overlay_data)-- return cls(- frame_number=aggregation_output.frame_number,- observation_overlays=observation_overlays,- tracked_points3d=aggregation_output.tracked_points3d- )-- def to_websocket_dict(self) -> dict:- """- Convert to dictionary suitable for JSON serialization over websocket.- """- payload = {- "frame_number": self.frame_number,- "observation_overlays": {- camera_id: overlay.model_dump()- for camera_id, overlay in self.observation_overlays.items()- },- "tracked_points3d": {- name: point.model_dump()- for name, point in self.tracked_points3d.items()- }- }-- return payload\ No newline at end of filediff --git a/freemocap/core/pipeline/pipeline_configs.py b/freemocap/core/pipeline/pipeline_configs.pyindex e500be41..df670cb7 100644--- a/freemocap/core/pipeline/pipeline_configs.py+++ b/freemocap/core/pipeline/pipeline_configs.py@@ -1,27 +1,108 @@-from abc import ABC+"""+Pipeline configuration types.-from pydantic import BaseModel, Field, ConfigDict+All detector/task configs live here. DetectorSpec is the picklable union+used to tell child processes which detector to instantiate.+"""+from enum import Enum++from pydantic import BaseModel, ConfigDict, Fieldfrom skellycam.core.camera.config.camera_config import CameraConfigsfrom skellycam.core.types.type_overloads import CameraIdString+from skellytracker.trackers.charuco_tracker.charuco_detector import CharucoDetectorConfig+from skellytracker.trackers.mediapipe_tracker import MediapipeDetectorConfig+from skellytracker.trackers.mediapipe_tracker.body.mediapipe_pose_config import MediapipePoseConfig+from skellytracker.trackers.mediapipe_tracker.mediapipe_model_manager import MediapipePoseModelComplexity+++from freemocap.core.calibration.pyceres_calibration.helpers.models import PyceresCalibrationSolverConfig+from freemocap.core.mocap.skeleton_dewiggler.realtime_skeleton_filter import RealtimeFilterConfig++# ---------------------------------------------------------------------------+# Detector spec: the picklable union that video nodes use to create detectors+# ---------------------------------------------------------------------------++DetectorSpec = CharucoDetectorConfig | MediapipeDetectorConfig+++def create_detector_from_spec(spec: DetectorSpec):+ """+ Create a detector instance from a picklable spec.+ Called inside child processes — detector class imports are deferred+ to avoid pulling in mediapipe/cv2.aruco during module import.+ """++ match spec:+ case CharucoDetectorConfig():+ from skellytracker.trackers.charuco_tracker.charuco_detector import CharucoDetector+ return CharucoDetector.create(config=spec)+ case MediapipeDetectorConfig():+ from skellytracker.trackers.mediapipe_tracker import MediapipeDetector+ return MediapipeDetector.create(config=spec)+ case _:+ raise TypeError(f"Unknown detector spec type: {type(spec).__name__}")-from skellytracker.trackers.mediapipe_tracker.mediapipe_detector import MediapipeDetectorConfig-from skellytracker.trackers.charuco_tracker.charuco_detector import CharucoDetectorConfig+def create_annotator_from_spec(spec: DetectorSpec):+ """+ Create an image annotator matching the given detector spec.+ Called inside child processes for drawing detection results onto frames.+ """+ from skellytracker.trackers.charuco_tracker.charuco_annotator import CharucoImageAnnotator, CharucoAnnotatorConfig+ from skellytracker.trackers.mediapipe_tracker import MediapipeAnnotator, MediapipeAnnotatorConfig+ match spec:+ case CharucoDetectorConfig():+ return CharucoImageAnnotator.create(config=CharucoAnnotatorConfig())+ case MediapipeDetectorConfig():+ return MediapipeAnnotator.create(config=MediapipeAnnotatorConfig())+ case _:+ raise TypeError(f"Unknown detector spec type for annotator: {type(spec).__name__}")-class PipelineConfigABC(BaseModel, ABC):- pass+# ---------------------------------------------------------------------------+# Calibration solver selection+# ----------------------------------------------------------------------------class CalibrationpipelineConfig(BaseModel):- # model_config = ConfigDict(extra="forbid")- calibration_recording_folder: str | None = Field(default=None, alias="calibrationRecordingFolder")++class CalibrationSolverMethod(str, Enum):+ """Which calibration solver backend to use."""+ ANIPOSE = "anipose"+ PYCERES = "pyceres"+++# ---------------------------------------------------------------------------+# Task configs+# ---------------------------------------------------------------------------+++class CalibrationPipelineConfig(BaseModel):+ model_config = ConfigDict(populate_by_name=True)++ calibration_recording_folder: str | None = Field(+ default=None, alias="calibrationRecordingFolder",+ )charuco_board_x_squares: int = Field(gt=0, default=5, alias="charucoBoardXSquares")charuco_board_y_squares: int = Field(gt=0, default=3, alias="charucoBoardYSquares")charuco_square_length: float = Field(gt=0, default=1, alias="charucoSquareLength")- # min_shared_views_per_camera: int = Field(gt=0, default=200, alias="minSharedViewsPerCamera")- # auto_stop_on_min_view_count: bool = Field(default=True, alias="autoStopOnMinViewCount")- # auto_process_recording: bool = Field(default=True, alias="autoProcessRecording")++ solver_method: CalibrationSolverMethod = Field(+ default=CalibrationSolverMethod.ANIPOSE,+ alias="solverMethod",+ description="Which calibration solver to use: 'anipose' (legacy) or 'pyceres' (new bundle adjustment).",+ )++ pyceres_solver_config: PyceresCalibrationSolverConfig = Field(+ default_factory=PyceresCalibrationSolverConfig,+ alias="pyceresSolverConfig",+ description="Configuration for the pyceres bundle adjustment solver. Only used when solver_method='pyceres'.",+ )++ use_groundplane: bool = Field(+ default=False,+ alias="useGroundplane",+ description="Align world frame to charuco board plane after calibration.",+ )@propertydef detector_config(self) -> CharucoDetectorConfig:@@ -30,15 +111,46 @@ class CalibrationpipelineConfig(BaseModel):squares_y=self.charuco_board_y_squares,square_length=self.charuco_square_length,)-class MocapPipelineTaskConfig(BaseModel):+@property- def detector_config(self) -> MediapipeDetectorConfig:- return MediapipeDetectorConfig()+ def detector_spec(self) -> DetectorSpec:+ return self.detector_config+++class MocapPipelineConfig(BaseModel):+ detector: MediapipeDetectorConfig+ skeleton_filter: RealtimeFilterConfig = Field(default_factory=RealtimeFilterConfig)++ @classmethod+ def default_realtime(cls) -> "MocapPipelineConfig":+ return cls(detector=MediapipeDetectorConfig(+ pose_config=MediapipePoseConfig(model_complexity=MediapipePoseModelComplexity.LITE)+ ))++ @classmethod+ def default_posthoc(cls) -> "MocapPipelineConfig":+ return cls(detector=MediapipeDetectorConfig(+ pose_config=MediapipePoseConfig(model_complexity=MediapipePoseModelComplexity.HEAVY)+ ))++++++# ---------------------------------------------------------------------------+# Top-level realtime pipeline config+# ---------------------------------------------------------------------------class RealtimePipelineConfig(BaseModel):camera_configs: CameraConfigs- calibration_task_config: CalibrationpipelineConfig = Field(default_factory=CalibrationpipelineConfig)- mocap_task_config: MocapPipelineTaskConfig = Field(default_factory=MocapPipelineTaskConfig)+ calibration_config: CalibrationPipelineConfig = Field(+ default_factory=CalibrationPipelineConfig,+ )+ mocap_config: MocapPipelineConfig = Field(+ default_factory=MocapPipelineConfig.default_realtime,+ )+ calibration_detection_enabled: bool = Field(default=True)+ mocap_detection_enabled: bool = Field(default=True)@propertydef camera_ids(self) -> list[CameraIdString]:@@ -46,7 +158,4 @@ class RealtimePipelineConfig(BaseModel):@classmethoddef from_camera_configs(cls, *, camera_configs: CameraConfigs) -> "RealtimePipelineConfig":- return cls(- camera_configs=camera_configs,-- )+ return cls(camera_configs=camera_configs)\ No newline at end of filediff --git a/freemocap/core/pipeline/pipeline_ipc.py b/freemocap/core/pipeline/pipeline_ipc.pyindex 6caee26d..c19b4baa 100644--- a/freemocap/core/pipeline/pipeline_ipc.py+++ b/freemocap/core/pipeline/pipeline_ipc.py@@ -1,11 +1,20 @@+"""+PipelineIPC: shared inter-process communication flags for a single pipeline.++Contains only the cross-process primitives that children need:+ - pipeline_id+ - global_kill_flag / pipeline_shutdown_flag+ - heartbeat_timestamp+ - ws_queue (for log forwarding)++PubSub is NOT on this object. Pipelines own pubsub separately and pass+bare queue handles to children as explicit kwargs.+"""import multiprocessingimport uuidfrom dataclasses import dataclass, field-from skellycam.core.ipc.pubsub.pubsub_topics import SetShmTopic-from freemocap.core.types.type_overloads import PipelineIdString-from freemocap.pubsub.pubsub_manager import PubSubTopicManager, create_pipeline_pubsub_managerfrom freemocap.system.logging_configuration.handlers.websocket_log_queue_handler import get_websocket_log_queuefrom freemocap.utilities.check_main_processs_heartbeat import check_main_process_heartbeat@@ -13,23 +22,25 @@ from freemocap.utilities.check_main_processs_heartbeat import check_main_process@dataclassclass PipelineIPC:pipeline_id: PipelineIdString- pubsub: PubSubTopicManagerws_queue: multiprocessing.Queueglobal_kill_flag: multiprocessing.Valueheartbeat_timestamp: multiprocessing.Value- pipeline_shutdown_flag: multiprocessing.Value = field(default_factory=lambda: multiprocessing.Value('b', False))+ pipeline_shutdown_flag: multiprocessing.Value = field(+ default_factory=lambda: multiprocessing.Value('b', False),+ )@classmethod- def create(cls,- global_kill_flag: multiprocessing.Value,- heartbeat_timestamp: multiprocessing.Value,- pipeline_id: PipelineIdString | None = None):+ def create(+ cls,+ *,+ global_kill_flag: multiprocessing.Value,+ heartbeat_timestamp: multiprocessing.Value,+ pipeline_id: PipelineIdString | None = None,+ ) -> "PipelineIPC":if pipeline_id is None:pipeline_id = str(uuid.uuid4())[:6]- pubsub = create_pipeline_pubsub_manager(pipeline_id=pipeline_id)return cls(pipeline_id=pipeline_id,- pubsub=pubsub,global_kill_flag=global_kill_flag,heartbeat_timestamp=heartbeat_timestamp,ws_queue=get_websocket_log_queue(),@@ -37,16 +48,20 @@ class PipelineIPC:@propertydef should_continue(self) -> bool:- return (not self.global_kill_flag.value- and not self.pipeline_shutdown_flag.value- and check_main_process_heartbeat(global_kill_flag=self.global_kill_flag,- heartbeat_timestamp=self.heartbeat_timestamp, ))+ return (+ not self.global_kill_flag.value+ and not self.pipeline_shutdown_flag.value+ and check_main_process_heartbeat(+ global_kill_flag=self.global_kill_flag,+ heartbeat_timestamp=self.heartbeat_timestamp,+ )+ )- def shutdown_pipeline(self):+ def shutdown_pipeline(self) -> None:+ """Signal this pipeline to stop. Does NOT touch the global kill flag."""self.pipeline_shutdown_flag.value = True- self.pubsub.close()-- def kill_everything(self):- self.shutdown_pipeline()- self.global_kill_flag.value = True+ def kill_everything(self) -> None:+ """Nuclear option: stop this pipeline AND signal global shutdown."""+ self.pipeline_shutdown_flag.value = True+ self.global_kill_flag.value = True\ No newline at end of filediff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/__init__.py b/freemocap/core/pipeline/posthoc/__init__.pysimilarity index 100%rename from freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/__init__.pyrename to freemocap/core/pipeline/posthoc/__init__.pydiff --git a/freemocap/core/pipeline/posthoc/posthoc_aggregation_node.py b/freemocap/core/pipeline/posthoc/posthoc_aggregation_node.pynew file mode 100644index 00000000..db873990--- /dev/null+++ b/freemocap/core/pipeline/posthoc/posthoc_aggregation_node.py@@ -0,0 +1,192 @@+"""+PosthocAggregationNode: collects all video node outputs, then calls a task function.++The frame-collection logic is written once here. The actual processing is+delegated to a task function (e.g. run_calibration_task, run_mocap_task)+passed in as a picklable callable.++The task function signature must be:++ def my_task(+ *,+ frame_observations: list[dict[VideoIdString, BaseObservation]],+ recording_info: RecordingInfo,+ video_metadata: dict[VideoIdString, VideoMetadata],+ report_progress: Callable[[str, float], None],+ ) -> None:++Additional task-specific kwargs are pre-bound via functools.partial.+"""+import logging+import multiprocessing+from collections.abc import Callable+from dataclasses import dataclass++from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry+from skellycam.core.recorders.videos.recording_info import RecordingInfo+from skellycam.core.types.type_overloads import TopicSubscriptionQueue++from freemocap.core.pipeline.base_node import BaseNode+from freemocap.core.pipeline.pipeline_ipc import PipelineIPC+from freemocap.core.pipeline.posthoc.video_group_helper import VideoMetadata+from freemocap.core.types.type_overloads import PipelineIdString, FrameNumberInt, VideoIdString+from freemocap.pubsub.pubsub_manager import PubSubTopicManager+from freemocap.pubsub.pubsub_topics import (+ VideoNodeOutputMessage,+ VideoNodeOutputTopic,+ PosthocProgressTopic,+)+from freemocap.utilities.wait_functions import wait_1ms++logger = logging.getLogger(__name__)++PosthocAggregationNodeTaskFn = Callable[..., None]+++@dataclass+class PosthocAggregationNode(BaseNode):++ @classmethod+ def create(+ cls,+ *,+ aggregation_task_fn: PosthocAggregationNodeTaskFn,+ video_metadata: dict[VideoIdString, VideoMetadata],+ pipeline_id: PipelineIdString,+ recording_info: RecordingInfo,+ worker_registry: WorkerRegistry,+ ipc: PipelineIPC,+ pubsub: PubSubTopicManager,+ ) -> "PosthocAggregationNode":+ shutdown_self_flag, worker = cls._create_worker(+ target=cls._run,+ name=f"Pipeline-{pipeline_id}-PosthocAggregationNode",+ worker_registry=worker_registry,+ log_queue=ipc.ws_queue,+ kwargs=dict(+ aggregation_task_fn=aggregation_task_fn,+ pipeline_id=pipeline_id,+ recording_info=recording_info,+ video_metadata=video_metadata,+ ipc=ipc,+ video_node_output_subscription=pubsub.get_subscription(+ VideoNodeOutputTopic,+ ),+ ),+ )+ return cls(+ shutdown_self_flag=shutdown_self_flag,+ worker=worker,+ )++ @staticmethod+ def _run(+ *,+ aggregation_task_fn: PosthocAggregationNodeTaskFn,+ pipeline_id: PipelineIdString,+ recording_info: RecordingInfo,+ video_metadata: dict[VideoIdString, VideoMetadata],+ ipc: PipelineIPC,+ shutdown_self_flag: multiprocessing.Value,+ video_node_output_subscription: TopicSubscriptionQueue,+ ) -> None:+ start_frames = set(vm.start_frame for vm in video_metadata.values())+ end_frames = set(vm.end_frame for vm in video_metadata.values())+ if len(start_frames) != 1 or len(end_frames) != 1:+ raise ValueError(+ f"Mismatched start/end frames across videos in pipeline {pipeline_id}: "+ f"start_frames={start_frames}, end_frames={end_frames}"+ )+ start_frame = start_frames.pop()+ end_frame = end_frames.pop()+ frame_numbers = list(range(start_frame, end_frame))+ video_ids = list(video_metadata.keys())+ total_expected = len(frame_numbers) * len(video_ids)++ logger.debug(+ f"PosthocAggregationNode [{pipeline_id}] starting — "+ f"expecting {len(frame_numbers)} frames × {len(video_ids)} videos "+ f"= {total_expected} outputs"+ )++ video_outputs_by_frame: dict[FrameNumberInt, dict[VideoIdString, VideoNodeOutputMessage | None]] = {+ frame_number: {vid: None for vid in video_ids}+ for frame_number in frame_numbers+ }+ got_all_by_frame: dict[FrameNumberInt, bool] = {fn: False for fn in frame_numbers}+ received_count: int = 0++ try:+ while not shutdown_self_flag.value and ipc.should_continue:+ wait_1ms()++ if video_node_output_subscription.empty():+ continue++ msg: VideoNodeOutputMessage = video_node_output_subscription.get()++ if msg.video_id not in video_ids:+ raise ValueError(+ f"Unexpected video ID '{msg.video_id}' — "+ f"expected one of {video_ids}"+ )+ if msg.frame_number not in video_outputs_by_frame:+ raise ValueError(+ f"Unexpected frame number {msg.frame_number} — "+ f"expected range [{start_frame}, {end_frame})"+ )++ video_outputs_by_frame[msg.frame_number][msg.video_id] = msg+ received_count += 1++ if all(+ isinstance(v, VideoNodeOutputMessage)+ for v in video_outputs_by_frame[msg.frame_number].values()+ ):+ got_all_by_frame[msg.frame_number] = True++ if all(got_all_by_frame.values()):+ break++ missing_frames = [fn for fn, complete in got_all_by_frame.items() if not complete]+ if missing_frames:+ raise RuntimeError(+ f"Pipeline {pipeline_id} ended with {len(missing_frames)} missing frames out of {total_expected}, "+ f"incomplete frames (shutdown_flag={shutdown_self_flag.value}, "+ f"should_continue={ipc.should_continue})"+ )++ logger.info(f"PosthocAggregationNode [{pipeline_id}] — all frames collected")+++ observations_by_frame: list[dict[VideoIdString, object]] = []+ for frame_number in frame_numbers:+ frame_data = video_outputs_by_frame[frame_number]+ observations = {}+ for vid_id, output_msg in frame_data.items():+ if not isinstance(output_msg, VideoNodeOutputMessage):+ raise RuntimeError(+ f"Missing output for video {vid_id} frame {frame_number}"+ )+ observations[vid_id] = output_msg.observation+ observations_by_frame.append(observations)++ aggregation_task_fn(+ frame_observations=observations_by_frame,+ recording_info=recording_info,+ video_metadata=video_metadata,+ )++ logger.info(f"PosthocAggregationNode [{pipeline_id}] — task completed")++ except Exception as e:+ logger.error(+ f"Exception in PosthocAggregationNode [{pipeline_id}]: {e}",+ exc_info=True,+ )+ ipc.shutdown_pipeline()+ raise+ finally:+ logger.debug(+ f"PosthocAggregationNode [{pipeline_id}] exiting"+ )\ No newline at end of filediff --git a/freemocap/core/pipeline/posthoc/posthoc_pipeline.py b/freemocap/core/pipeline/posthoc/posthoc_pipeline.pynew file mode 100644index 00000000..744cf946--- /dev/null+++ b/freemocap/core/pipeline/posthoc/posthoc_pipeline.py@@ -0,0 +1,171 @@+"""+PosthocPipeline: a fire-and-forget pipeline that processes recorded video.++Replaces both PosthocCalibrationProcessingPipeline and PosthocMocapProcessingPipeline.+The pipeline is parameterized by:+ - detector_spec: what detector to run in the video nodes+ - task_fn: what processing to do in the aggregation node after collecting all frames++The pipeline self-terminates when processing is complete. All processes exit+naturally when their work is done.+"""+import logging+import multiprocessing+import sys+import time+import uuid+from dataclasses import dataclass+from pathlib import Path+from typing import ClassVar++from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry+from skellycam.core.recorders.videos.recording_info import RecordingInfo++from freemocap.core.pipeline.pipeline_configs import DetectorSpec+from freemocap.core.pipeline.pipeline_ipc import PipelineIPC+from freemocap.core.pipeline.posthoc.posthoc_aggregation_node import PosthocAggregationNode, \+ PosthocAggregationNodeTaskFn+from freemocap.core.pipeline.posthoc.video_group_helper import VideoGroupHelper+from freemocap.core.pipeline.posthoc.video_node import VideoNode+from freemocap.core.types.type_overloads import PipelineIdString, VideoIdString+from freemocap.pubsub.pubsub_manager import PubSubTopicManager++logger = logging.getLogger(__name__)+++@dataclass+class PosthocPipeline:+ """+ Generic posthoc pipeline: video nodes → aggregation node → task function.++ Self-terminates when processing is complete. Check .alive to see if it's+ still running, or subscribe to PosthocProgressTopic for status updates.+ """+ id: PipelineIdString+ recording_info: RecordingInfo+ video_nodes: dict[VideoIdString, VideoNode]+ aggregation_node: PosthocAggregationNode+ ipc: PipelineIPC+ pubsub: PubSubTopicManager+ started: bool = False++ @property+ def alive(self) -> bool:+ """True if any worker process is still running."""+ if not self.started:+ return False+ any_alive = any(node.is_alive for node in self.video_nodes.values())+ return any_alive or self.aggregation_node.is_alive++ @property+ def video_ids(self) -> list[VideoIdString]:+ return list(self.video_nodes.keys())++ @classmethod+ def create(+ cls,+ *,+ recording_info: RecordingInfo,+ detector_spec: DetectorSpec,+ task_fn: PosthocAggregationNodeTaskFn,+ worker_registry: WorkerRegistry,+ global_kill_flag: multiprocessing.Value,+ save_annotated_video: bool = True,+ ) -> "PosthocPipeline":+ """+ Create a posthoc pipeline.++ Args:+ recording_info: Where to find the recorded videos.+ detector_spec: Which detector to run on each video frame.+ task_fn: The processing function (with task_config pre-bound via+ functools.partial) to call after all frames are collected.+ worker_registry: For creating managed processes.+ global_kill_flag: Shared app-wide kill flag.+ save_annotated_video: Write annotated video output during detection.+ If an annotated video already exists, new annotations are layered+ on top of the existing one.+ """+ recording_path = Path(recording_info.full_recording_path)++ video_group = VideoGroupHelper.from_recording_path(+ recording_path=str(recording_path),+ )++ pipeline_id: PipelineIdString = str(uuid.uuid4())[:6]++ ipc = PipelineIPC.create(+ global_kill_flag=global_kill_flag,+ heartbeat_timestamp=worker_registry.heartbeat_timestamp,+ pipeline_id=pipeline_id,+ )+ pubsub = PubSubTopicManager.create(+ global_kill_flag=global_kill_flag,+ )++ video_nodes: dict[VideoIdString, VideoNode] = {}+ for video_id, video_helper in video_group.videos.items():+ video_nodes[video_id] = VideoNode.create(+ video_id=video_id,+ video_path=video_helper.video_path,+ detector_spec=detector_spec,+ worker_registry=worker_registry,+ ipc=ipc,+ pubsub=pubsub,+ recording_path=recording_path,+ save_annotated_video=save_annotated_video,+ )++ aggregation_node = PosthocAggregationNode.create(+ aggregation_task_fn=task_fn,+ video_metadata=video_group.video_metadata_by_id,+ pipeline_id=pipeline_id,+ recording_info=recording_info,+ worker_registry=worker_registry,+ ipc=ipc,+ pubsub=pubsub,+ )++ video_group.close()++ return cls(+ id=pipeline_id,+ recording_info=recording_info,+ video_nodes=video_nodes,+ aggregation_node=aggregation_node,+ ipc=ipc,+ pubsub=pubsub,+ )++++ def start(self) -> None:+ """Start all video nodes then the aggregation node."""+ if self.started:+ raise RuntimeError(f"PosthocPipeline {self.id} already started")+ self.started = True+ logger.info(+ f"Starting PosthocPipeline [{self.id}] for recording "+ f"'{self.recording_info.recording_name}' "+ f"with {len(self.video_nodes)} video node(s)"+ )++ nodes = list(self.video_nodes.values())+ for i, node in enumerate(nodes):+ node.start()+++ self.aggregation_node.start()+ logger.info(f"PosthocPipeline [{self.id}] — all workers started")++ def shutdown(self) -> None:+ """Force-shutdown the pipeline (for cleanup or cancellation)."""+ logger.debug(f"Shutting down PosthocPipeline [{self.id}]")+ self.ipc.shutdown_pipeline()+ self.pubsub.close()+ for node in self.video_nodes.values():+ if node.is_alive:+ node.shutdown()+ if self.aggregation_node.is_alive:+ self.aggregation_node.shutdown()+ logger.debug(f"PosthocPipeline [{self.id}] shut down")\ No newline at end of filediff --git a/freemocap/core/pipeline/posthoc/posthoc_pipeline_manager.py b/freemocap/core/pipeline/posthoc/posthoc_pipeline_manager.pynew file mode 100644index 00000000..10ab86b3--- /dev/null+++ b/freemocap/core/pipeline/posthoc/posthoc_pipeline_manager.py@@ -0,0 +1,149 @@+"""+PosthocPipelineManager: lifecycle manager for fire-and-forget posthoc pipelines.++Each posthoc pipeline processes a recorded video group through detection and+a task function (calibration, mocap, etc.), then self-terminates. The processes+log their own errors and report progress via pubsub — the manager just tracks+them for cancellation/shutdown purposes.++Dead pipelines are cleaned up lazily whenever the manager is accessed.+"""+import functools+import logging+import multiprocessing+from dataclasses import dataclass, field++from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry+from skellycam.core.recorders.videos.recording_info import RecordingInfo++from freemocap.core.calibration.calibration_task import run_calibration_task+from freemocap.core.mocap.mocap_task import run_mocap_task+from freemocap.core.pipeline.pipeline_configs import CalibrationPipelineConfig, MocapPipelineConfig+from freemocap.core.pipeline.posthoc.posthoc_pipeline import PosthocPipeline+from freemocap.core.types.type_overloads import PipelineIdString++logger = logging.getLogger(__name__)+++@dataclass+class PosthocPipelineManager:+ """+ Manages fire-and-forget posthoc pipelines.++ Pipelines self-terminate when processing completes. The manager tracks+ them only for force-shutdown / cancellation. Dead entries are evicted+ lazily on access.+ """++ global_kill_flag: multiprocessing.Value+ worker_registry: WorkerRegistry+ lock: multiprocessing.Lock = field(default_factory=multiprocessing.Lock)+ pipelines: dict[PipelineIdString, PosthocPipeline] = field(default_factory=dict)++ # ------------------------------------------------------------------+ # Lazy cleanup+ # ------------------------------------------------------------------++ def _evict_dead(self) -> None:+ """Remove pipelines whose processes have all exited. Caller must hold self.lock.++ Calls shutdown() on each dead pipeline to release PubSub resources+ (relay thread, multiprocessing.Queue instances, OS pipes).+ """+ dead_ids: list[PipelineIdString] = [+ pid for pid, pipeline in self.pipelines.items()+ if pipeline.started and not pipeline.alive+ ]+ for pid in dead_ids:+ pipeline = self.pipelines.pop(pid)+ pipeline.shutdown()+ logger.debug(+ f"Evicted completed PosthocPipeline [{pid}] "+ f"for '{pipeline.recording_info.recording_name}'"+ )++ def evict_completed(self) -> None:+ """Clean up any posthoc pipelines that have finished running.++ Safe to call frequently — skips lock acquisition when there are no+ pipelines to check.+ """+ if not self.pipelines:+ return+ with self.lock:+ self._evict_dead()++ # ------------------------------------------------------------------+ # Pipeline creation+ # ------------------------------------------------------------------++ def create_calibration_pipeline(+ self,+ *,+ recording_info: RecordingInfo,+ calibration_config: CalibrationPipelineConfig,+ ) -> PosthocPipeline:+ calibration_aggregation_task_fn = functools.partial(+ run_calibration_task,+ task_config=calibration_config,+ )+ pipeline = PosthocPipeline.create(+ recording_info=recording_info,+ detector_spec=calibration_config.detector_spec,+ task_fn=calibration_aggregation_task_fn,+ worker_registry=self.worker_registry,+ global_kill_flag=self.global_kill_flag,+ )+ pipeline.start()+ with self.lock:+ self._evict_dead()+ self.pipelines[pipeline.id] = pipeline+ logger.info(+ f"Created posthoc calibration pipeline [{pipeline.id}] "+ f"for '{recording_info.recording_name}'"+ )+ return pipeline++ def create_mocap_pipeline(+ self,+ *,+ recording_info: RecordingInfo,+ mocap_config: MocapPipelineConfig,+ ) -> PosthocPipeline:+ task_fn = functools.partial(+ run_mocap_task,+ task_config=mocap_config,+ )+ pipeline = PosthocPipeline.create(+ recording_info=recording_info,+ detector_spec=mocap_config.detector,+ task_fn=task_fn,+ worker_registry=self.worker_registry,+ global_kill_flag=self.global_kill_flag,+ )+ pipeline.start()+ with self.lock:+ self._evict_dead()+ self.pipelines[pipeline.id] = pipeline+ logger.info(+ f"Created posthoc mocap pipeline [{pipeline.id}] "+ f"for '{recording_info.recording_name}'"+ )+ return pipeline++ # ------------------------------------------------------------------+ # Lifecycle+ # ------------------------------------------------------------------++ def shutdown(self) -> None:+ """Force-shutdown all posthoc pipelines (running or completed).++ Calls shutdown() on every pipeline to release PubSub resources,+ not just alive ones — completed pipelines still hold relay threads+ and multiprocessing.Queue instances until explicitly closed.+ """+ with self.lock:+ for pipeline in self.pipelines.values():+ pipeline.shutdown()+ self.pipelines.clear()+ logger.info("PosthocPipelineManager: all pipelines shut down")\ No newline at end of filediff --git a/freemocap/core/pipeline/posthoc_pipelines/video_helper.py b/freemocap/core/pipeline/posthoc/video_group_helper.pysimilarity index 89%rename from freemocap/core/pipeline/posthoc_pipelines/video_helper.pyrename to freemocap/core/pipeline/posthoc/video_group_helper.pyindex c39a1b34..98d33a14 100644--- a/freemocap/core/pipeline/posthoc_pipelines/video_helper.py+++ b/freemocap/core/pipeline/posthoc/video_group_helper.py@@ -3,12 +3,14 @@ Simplified VideoHelper with OpenCV best practices.Includes smart frame reading and caching."""-from pathlib import Pathfrom collections import OrderedDict+from pathlib import Path+import cv2import numpy as npfrom pydantic import BaseModel, Field, ConfigDict, model_validator+from freemocap.core.calibration.shared.camera_identity import camera_ids_from_video_pathsfrom freemocap.core.types.type_overloads import VideoIdString# Module level constants@@ -30,15 +32,18 @@ class VideoMetadata(BaseModel):@model_validator(mode="before")def validate_frames(cls, values):start_frame = values.get("start_frame", 0)- values["end_frame"] = values.get("end_frame", values.get("frame_count"))+ total_frame_count = values.get("frame_count")+ values["end_frame"] = values.get("end_frame", total_frame_count)end_frame = values["end_frame"]- frame_count = end_frame - start_frame if end_frame is not None else values.get("frame_count")- if end_frame is not None:- if not (0 <= start_frame < end_frame <= frame_count):- raise ValueError(f"Invalid start_frame or end_frame values: start_frame={start_frame}, end_frame={end_frame}, frame_count={frame_count}")- if not (end_frame - start_frame) == frame_count:- raise ValueError(f"Subset frame count does not match frame_count: {end_frame - start_frame} != {frame_count}")-+ if end_frame is not None and total_frame_count is not None:+ if not (0 <= start_frame < end_frame):+ raise ValueError(+ f"Invalid frame range: start_frame={start_frame}, end_frame={end_frame}"+ )+ if end_frame > total_frame_count:+ raise ValueError(+ f"end_frame ({end_frame}) exceeds total frame_count ({total_frame_count})"+ )return values@@ -344,20 +349,24 @@ class VideoGroupHelper(BaseModel):return self@classmethod- def from_video_paths(cls, video_paths: list[VideoIdString], close_videos:bool=True) -> "VideoGroupHelper":- video_paths = sorted(video_paths) # sort to ensure consistent ordering+ def from_video_paths(cls, video_paths: list[str], close_videos: bool = True) -> "VideoGroupHelper":+ """Create VideoGroupHelper from a list of video file paths.- videos: dict[VideoIdString, VideoHelper] = {}+ Camera IDs are extracted from video filenames when possible.+ Falls back to sorted positional indices if extraction fails.+ """+ id_to_path = camera_ids_from_video_paths(+ video_paths=[Path(p) for p in video_paths],+ )- for video_number, video_path in enumerate(video_paths):- video_name = Path(video_path).name- # camera_id = extract_camera_id(video_name)- # TODO - Just using video order index as video ID for now, need revisit this later to couple this to Camera Id somehow. Its a tricky problem.- videos[str(video_number)] = VideoHelper.from_video_path(Path(video_path))+ videos: dict[VideoIdString, VideoHelper] = {}+ for camera_id, video_path in id_to_path.items():+ videos[camera_id] = VideoHelper.from_video_path(video_path)- instance = cls(videos=videos,- video_metadata_by_id={vid_id: vid.metadata for vid_id, vid in videos.items()})- #close videos+ instance = cls(+ videos=videos,+ video_metadata_by_id={vid_id: vid.metadata for vid_id, vid in videos.items()},+ )if close_videos:instance.close()return instance@@ -377,6 +386,7 @@ class VideoGroupHelper(BaseModel):def close(self):for video in self.videos.values():video.close()+# Example usageif __name__ == "__main__":video_path = Path(r"C:\Users\jonma\Downloads\2025-07-01_ferret_757_EyeCameras_P33_EO5_1m_20s-2m_20s(2).mp4")diff --git a/freemocap/core/pipeline/posthoc/video_node.py b/freemocap/core/pipeline/posthoc/video_node.pynew file mode 100644index 00000000..74f1d32c--- /dev/null+++ b/freemocap/core/pipeline/posthoc/video_node.py@@ -0,0 +1,224 @@+"""+VideoNode: reads frames from a video file, runs a detector, publishes observations.++Generic video processing node parameterized by DetectorSpec — the same node+handles charuco detection, mediapipe detection, or any future detector type.++Optionally saves annotated video output. If an existing annotated video is found+in the annotated_videos/ folder, new annotations are drawn on top of those frames+(allowing layering of e.g. charuco + mediapipe annotations). Otherwise, annotations+are drawn on the source video frames.+"""+import logging+import multiprocessing+from dataclasses import dataclass+from pathlib import Path++import cv2+from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry++from freemocap.core.pipeline.base_node import BaseNode+from freemocap.core.pipeline.pipeline_configs import DetectorSpec, create_detector_from_spec, create_annotator_from_spec+from freemocap.core.pipeline.pipeline_ipc import PipelineIPC+from freemocap.core.types.type_overloads import VideoIdString, TopicPublicationQueue+from freemocap.pubsub.pubsub_manager import PubSubTopicManager+from freemocap.pubsub.pubsub_topics import VideoNodeOutputTopic, VideoNodeOutputMessage++logger = logging.getLogger(__name__)++ANNOTATED_VIDEOS_FOLDER_NAME = "annotated_videos"+++@dataclass+class VideoNode(BaseNode):+ video_id: VideoIdString+ video_path: Path++ @classmethod+ def create(+ cls,+ *,+ video_id: VideoIdString,+ video_path: Path,+ detector_spec: DetectorSpec,+ worker_registry: WorkerRegistry,+ ipc: PipelineIPC,+ pubsub: PubSubTopicManager,+ recording_path: Path,+ save_annotated_video: bool = True,+ ) -> "VideoNode":+ shutdown_self_flag, worker = cls._create_worker(+ target=cls._run,+ name=f"VideoNode-{video_path.stem}",+ worker_registry=worker_registry,+ log_queue=ipc.ws_queue,+ kwargs=dict(+ video_id=video_id,+ video_path=video_path,+ detector_spec=detector_spec,+ ipc=ipc,+ video_output_pub=pubsub.get_publication_queue(+ VideoNodeOutputTopic,+ ),+ recording_path=recording_path,+ save_annotated_video=save_annotated_video,+ ),+ )+ return cls(+ video_id=video_id,+ video_path=video_path,+ shutdown_self_flag=shutdown_self_flag,+ worker=worker,+ )++ @staticmethod+ def _resolve_annotated_video_paths(+ *,+ recording_path: Path,+ video_path: Path,+ ) -> tuple[Path, Path | None]:+ """+ Determine the output path for the annotated video and check if an+ existing annotated video can be used as the base for layered annotation.++ Returns:+ (output_path, existing_base_path_or_none)+ """+ annotated_dir = recording_path / ANNOTATED_VIDEOS_FOLDER_NAME+ annotated_dir.mkdir(parents=True, exist_ok=True)++ output_path = annotated_dir / f"{video_path.stem}_annotated{video_path.suffix}"+++++ # If an annotated video already exists, rename it so we can read from it+ # while writing the new layered version+ existing_base_path: Path | None = None+ if output_path.exists():+ existing_base_path = output_path.with_suffix(+ f".prev{output_path.suffix}"+ )+ output_path.rename(existing_base_path)+ logger.info(+ f"Found existing annotated video for {video_path.stem}, "+ f"will layer new annotations on top"+ )++ return output_path, existing_base_path++ @staticmethod+ def _run(+ *,+ video_id: VideoIdString,+ video_path: Path,+ detector_spec: DetectorSpec,+ ipc: PipelineIPC,+ video_output_pub: TopicPublicationQueue,+ shutdown_self_flag: multiprocessing.Value,+ recording_path: Path,+ save_annotated_video: bool,+ ) -> None:+ detector = create_detector_from_spec(detector_spec)+ video_reader = cv2.VideoCapture(str(video_path), cv2.CAP_FFMPEG)+ if not video_reader.isOpened():+ raise RuntimeError(f"Failed to open video file: {video_path}")++ # Set up annotation pipeline if requested+ annotator = None+ video_writer: cv2.VideoWriter | None = None+ base_reader: cv2.VideoCapture | None = None+ prev_annotated_path: Path | None = None++ if save_annotated_video:+ annotator = create_annotator_from_spec(detector_spec)+ annotated_output_path, prev_annotated_path = VideoNode._resolve_annotated_video_paths(+ recording_path=recording_path,+ video_path=video_path,+ )++ # Open base reader if we have a previous annotated video to layer on+ if prev_annotated_path is not None:+ base_reader = cv2.VideoCapture(str(prev_annotated_path), cv2.CAP_FFMPEG)+ if not base_reader.isOpened():+ raise RuntimeError(+ f"Failed to open previous annotated video: {prev_annotated_path}"+ )++ # Create video writer matching source video properties+ fps = video_reader.get(cv2.CAP_PROP_FPS)+ width = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH))+ height = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT))+ fourcc = cv2.VideoWriter_fourcc(*"mp4v")+ video_writer = cv2.VideoWriter(+ str(annotated_output_path), fourcc, fps, (width, height)+ )+ if not video_writer.isOpened():+ raise RuntimeError(+ f"Failed to create video writer for: {annotated_output_path}"+ )++ logger.info(+ f"VideoNode started for {video_path.stem}"+ f"{' (with annotation)' if save_annotated_video else ''}"+ )+ frame_number: int = 0+ try:+ success, image = video_reader.read()+ while success and not shutdown_self_flag.value and ipc.should_continue:+ observation = detector.detect(+ frame_number=frame_number,+ image=image,+ )+ video_output_pub.put(+ VideoNodeOutputMessage(+ video_id=video_id,+ frame_number=frame_number,+ observation=observation,+ ),+ )++ # Annotate and write frame if enabled+ if annotator is not None and video_writer is not None:+ # Use previous annotated frame as base if available, else source frame+ if base_reader is not None:+ base_ok, base_frame = base_reader.read()+ if not base_ok or base_frame is None:+ raise RuntimeError(+ f"Previous annotated video ran out of frames at frame {frame_number} "+ f"for {video_path.stem} — frame count mismatch with source video"+ )+ annotation_base = base_frame+ else:+ annotation_base = image++ annotated_frame = annotator.annotate_image(+ image=annotation_base,+ observation=observation,+ )+ video_writer.write(annotated_frame)++ success, image = video_reader.read()+ frame_number += 1++ logger.info(+ f"VideoNode for {video_path.stem} finished reading "+ f"{frame_number} frames"+ )++ except Exception as e:+ logger.exception(+ f"Exception in VideoNode for {video_path.stem}: {e}"+ )+ ipc.shutdown_pipeline()+ raise+ finally:+ video_reader.release()+ if video_writer is not None:+ video_writer.release()+ if base_reader is not None:+ base_reader.release()+ # Clean up the .prev file after we're done reading from it+ if prev_annotated_path is not None and prev_annotated_path.exists():+ prev_annotated_path.unlink()+ logger.debug(f"VideoNode for {video_path.stem} exiting")\ No newline at end of filediff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/camera_math_models.py b/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/camera_math_models.pydeleted file mode 100644index f28fcafd..00000000--- a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/camera_math_models.py+++ /dev/null@@ -1,236 +0,0 @@-import cv2-import numpy as np-from numpydantic import NDArray, Shape-from pydantic import BaseModel, model_validator-from scipy.spatial.transform import Rotation as R--from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.calibration_numpy_types import QuaternionArray, \- RotationVectorArray, \- RotationMatrixArray, TranslationVectorArray, CameraExtrinsicsMatrix, CameraDistortionCoefficientsArray, \- CameraMatrixArray---def karcher_mean_quaternions(quaternions: list[QuaternionArray], tol=1e-9, max_iterations=100):- # Normalize the quaternions to ensure they are unit quaternions-- quaternions = np.array([q / np.linalg.norm(q) for q in quaternions])-- # Start with an initial guess (the first quaternion)- mean_quat = quaternions[0]-- for _ in range(max_iterations):- # Compute the tangent vectors (logarithm map)- errors = [R.from_quat(q).inv() * R.from_quat(mean_quat) for q in quaternions]- errors = [e.as_rotvec() for e in errors]-- # Compute the average error vector- mean_error = np.mean(errors, axis=0)-- # Check for convergence- if np.linalg.norm(mean_error) < tol:- break-- # Update the mean (exponential map)- mean_rot = R.from_rotvec(mean_error) * R.from_quat(mean_quat)- mean_quat = mean_rot.as_quat(canonical=False)-- return mean_quat---class RotationVector(BaseModel):- vector: RotationVectorArray- reference_frame: str-- @property- def as_rotation_matrix(self) -> RotationMatrixArray:- return cv2.Rodrigues(self.vector)[0]-- @property- def as_quaternion(self) -> QuaternionArray:- return R.from_matrix(self.as_rotation_matrix).as_quat(canonical=False)-- @classmethod- def mean_from_rotation_vectors(cls, rotation_vectors: list["RotationVector"]) -> "RotationVector":- if not all([rv.reference_frame == rotation_vectors[0].reference_frame for rv in rotation_vectors]):- raise ValueError("All rotation vectors must have the same reference frame!")- quaternions = [rv.as_quaternion for rv in rotation_vectors]-- # Compute the Karcher mean of the quaternions- mean_quat = karcher_mean_quaternions(quaternions)-- # Convert the mean quaternion back to a rotation vector- mean_rotation = R.from_quat(mean_quat)- mean_rotation_vector = mean_rotation.as_rotvec()-- # Assuming all rotation vectors have the same reference frame- reference_frame = rotation_vectors[0].reference_frame-- return cls(vector=mean_rotation_vector,- reference_frame=reference_frame)---class TranslationVector(BaseModel):- vector: TranslationVectorArray- reference_frame: str-- @classmethod- def mean_from_translation_vectors(cls, translation_vectors: list["TranslationVector"]) -> "TranslationVector":- if not all([tv.reference_frame == translation_vectors[0].reference_frame for tv in translation_vectors]):- raise ValueError("All translation vectors must have the same reference frame!")- mean_translation_vector = np.mean([tv.vector for tv in translation_vectors], axis=0)-- # Assuming all rotation vectors have the same reference frame- reference_frame = translation_vectors[0].reference_frame-- return cls(vector=mean_translation_vector,- reference_frame=reference_frame)---class TransformationMatrix(BaseModel):- matrix: NDArray[Shape["4, 4"], np.float64]- reference_frame: str-- @classmethod- def from_extrinsics(cls, extrinsics_matrix: CameraExtrinsicsMatrix, reference_frame: str):- rotation_matrix = np.squeeze(extrinsics_matrix[:3, :3])- translation_vector = np.squeeze(extrinsics_matrix[:3, 3])- return cls.from_rotation_translation(- rotation_vector=RotationVector(vector=np.squeeze(cv2.Rodrigues(rotation_matrix)[0]),- reference_frame=reference_frame),- translation_vector=TranslationVector(vector=translation_vector,- reference_frame=reference_frame))-- @classmethod- def from_rotation_translation(cls,- rotation_vector: RotationVector,- translation_vector: TranslationVector):- if rotation_vector.reference_frame != translation_vector.reference_frame:- raise ValueError("Rotation and translation vectors must be in the same reference frame")- rotation_matrix = rotation_vector.as_rotation_matrix- transformation_matrix = np.eye(4)- transformation_matrix[:3, :3] = rotation_matrix- transformation_matrix[:3, 3] = translation_vector.vector- return cls(matrix=transformation_matrix, reference_frame=translation_vector.reference_frame)-- @classmethod- def mean_from_transformation_matrices(cls, transformation_matrices: list[- "TransformationMatrix"]) -> "TransformationMatrix":- if not all(- [tm.reference_frame == transformation_matrices[0].reference_frame for tm in transformation_matrices]):- raise ValueError("All transformation matrices must have the same reference frame!")-- rotation_vectors = [tm.rotation_vector for tm in transformation_matrices]- translation_vectors = [tm.translation_vector for tm in transformation_matrices]-- mean_rotation_vector = RotationVector.mean_from_rotation_vectors(rotation_vectors)- mean_translation_vector = TranslationVector.mean_from_translation_vectors(translation_vectors)-- return cls.from_rotation_translation(rotation_vector=mean_rotation_vector,- translation_vector=mean_translation_vector)-- @property- def rotation_matrix(self) -> NDArray[Shape["3, 3"], np.float32]:- return self.matrix[:3, :3]-- @property- def translation_vector(self) -> TranslationVector:- return TranslationVector(vector=self.matrix[:3, 3], reference_frame=self.reference_frame)-- @property- def rotation_vector(self) -> RotationVector:- return RotationVector(vector=np.squeeze(cv2.Rodrigues(self.rotation_matrix)[0]),- reference_frame=self.reference_frame)-- @property- def extrinsics_matrix(self) -> CameraExtrinsicsMatrix:- return self.matrix[:3, :]-- def get_inverse(self):- inverse_rotation_matrix = self.rotation_matrix.T- inverse_translation_vector = -inverse_rotation_matrix @ self.translation_vector.vector-- inverse_matrix = np.eye(4)- inverse_matrix[:3, :3] = inverse_rotation_matrix- inverse_matrix[:3, 3] = inverse_translation_vector-- return TransformationMatrix(matrix=inverse_matrix, reference_frame=self.reference_frame)-- def __matmul__(self, other: "TransformationMatrix") -> "TransformationMatrix":- if not isinstance(other, TransformationMatrix):- raise TypeError(- "Unsupported operand type(s) for @: 'TransformationMatrix' and '{}'".format(type(other).__name__))- # Perform matrix multiplication and use self's reference frame- return TransformationMatrix(matrix=self.matrix @ other.matrix, reference_frame=self.reference_frame)-- def __str__(self) -> str:- return (f"\treference_frame={self.reference_frame},\n"- f"\tmatrix=\n"- f"\t\t{self.matrix[0, :]:.3f},\n"- f"\t\t{self.matrix[1, :]:.3f},\n"- f"\t\t{self.matrix[2, :]:.3f},\n"- f"\t\t{self.matrix[3, :]:.3f},\n")---class CameraDistortionCoefficients(BaseModel):- """- https://docs.opencv.org/4.x/d9/d0c/group__calib3d.html- Distortion coefficients for the camera, must be either 4, 5, 8, 12, or 14 values.-- 0-3 are k1, k2, p1, p2- 4 is k3- 5-7 are k4, k5, k6- 8-11 are s1, s2, s3, s4- 12-13 are τ1, τ2 (τ like tau)-- `k` values refer to radial distortion coefficients- `p` values refer to tangential distortion coefficients- `s` values refer to thin prism distortion coefficients- `τ` values refer to x/y values of the 'tilted sensor' model-- NOTE - RECOMMEND USING 4 or 5 VALUES, things get weird with more than 5- """- coefficients: CameraDistortionCoefficientsArray-- @model_validator(mode="after")- def validate(self):- self.coefficients = np.squeeze(self.coefficients)- if len(self.coefficients) not in [4, 5, 8, 12, 14]:- raise ValueError("Invalid number of distortion coefficients. Must be 4, 5, 8, 12, or 14.")- return self---class CameraMatrix(BaseModel):- matrix: CameraMatrixArray-- @classmethod- def from_image_size(cls, image_size: tuple[int, ...]):- camera_matrix = np.eye(3)- camera_matrix[0, 2] = image_size[0] / 2 # x_center- camera_matrix[1, 2] = image_size[1] / 2 # y_center- return cls(matrix=camera_matrix)-- @model_validator(mode="after")- def validate(self):- if self.matrix.shape != (3, 3):- raise ValueError("Camera matrix must be 3x3")- return self-- @property- def focal_length(self) -> float:- return self.matrix[0, 0]-- @property- def focal_length_x(self) -> float:- return self.matrix[0, 0]-- @property- def focal_length_y(self) -> float:- return self.matrix[1, 1]-- @property- def focal_length_xy(self) -> float:- return (self.focal_length_x + self.focal_length_y) / 2-- @property- def principal_point(self) -> tuple[float, float]:- return self.matrix[0, 2], self.matrix[1, 2]diff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/charuco_groundplane_utils.py b/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/charuco_groundplane_utils.pydeleted file mode 100644index ec1b55f7..00000000--- a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/charuco_groundplane_utils.py+++ /dev/null@@ -1,130 +0,0 @@-import numpy as np-import pandas as pd---class CharucoVisibilityError(RuntimeError):- """Raised when no frame satisfies the ‘all-corners-visible & stationary’ criteria."""---class CharucoVelocityError(RuntimeError):- """Raised when the velocity of the ChArUco corners is too high to be considered stationary."""---def get_charuco_x_and_y_idx(number_of_squares_width: int, number_of_squares_height: int):- """- For a given board definition, get the corner marker indexes needed to make the x and y vectors- """-- num_cols = number_of_squares_width - 1 # corner columns- num_rows = number_of_squares_height - 1 # corner rows-- idx_x = num_cols * (num_rows - 1)- idx_y = num_cols - 1-- return idx_x, idx_y---def get_unit_vector(vector: np.ndarray) -> np.ndarray:- return vector / np.linalg.norm(vector)---def compute_basis_vectors_of_new_reference(- charuco_frame: np.ndarray, number_of_squares_width: int, number_of_squares_height: int-) -> tuple[np.ndarray, np.ndarray, np.ndarray]:- origin = charuco_frame[0]-- idx_x, idx_y = get_charuco_x_and_y_idx(- number_of_squares_width=number_of_squares_width, number_of_squares_height=number_of_squares_height- )-- x_vec = charuco_frame[idx_x] - origin- y_vec = charuco_frame[idx_y] - origin-- x_hat = get_unit_vector(x_vec)- y_hat_raw = get_unit_vector(y_vec)- z_hat = get_unit_vector(np.cross(x_hat, y_hat_raw))- y_hat = get_unit_vector(np.cross(z_hat, x_hat))-- return x_hat, y_hat, z_hat---def find_still_frame(points_velocity: np.ndarray, max_allowed_velocity: float = 1.0) -> int:- visible_frames = ~np.isnan(points_velocity).any(axis=1)- if not np.any(visible_frames):- raise CharucoVisibilityError(- "No frame found where all three required ChArUco corners are on the ground and visible."- )-- max_velocity_per_frame = np.nanmax(points_velocity[visible_frames], axis=1)- if np.nanmin(max_velocity_per_frame) > max_allowed_velocity:- raise CharucoVelocityError(- f"All frames have ChArUco corner velocity > {max_allowed_velocity:.2f} mm/s — check that the board is stationary."- )-- best_visible_index = int(np.nanargmin(max_velocity_per_frame))- best_velocity_index = np.where(visible_frames)[0][- best_visible_index- ] # maps back to the original array (which we sliced earlier to get rid of rows with nans)- return best_velocity_index---def find_good_frame(- charuco_data3d_fr_id_xyz: np.ndarray,- number_of_squares_width: int,- number_of_squares_height: int,- frame_to_use: int = 0,- search_range: int = 120,-):- if frame_to_use == 0:- slice_to_search = slice(0, search_range)- elif frame_to_use == -1:- slice_to_search = slice(-search_range, None)- elif frame_to_use > 0:- start_frame = max(0, frame_to_use - search_range)- end_frame = min(charuco_data3d_fr_id_xyz.shape[0], frame_to_use + search_range)- slice_to_search = slice(start_frame, end_frame)- else:- raise ValueError(f"Invalid value for frame_to_use: {frame_to_use}")-- idx_x, idx_y = get_charuco_x_and_y_idx(- number_of_squares_width=number_of_squares_width, number_of_squares_height=number_of_squares_height- )-- charuco_corners = charuco_data3d_fr_id_xyz[slice_to_search, [0, idx_y, idx_x]]- charuco_corners_velocity = np.linalg.norm(np.diff(charuco_corners, axis=0), axis=2)- best_velocity_frame = find_still_frame(points_velocity=charuco_corners_velocity)-- frame_offset = slice_to_search.start or 0- best_position_frame = best_velocity_frame + frame_offset + 1- return best_position_frame---def interpolate_skeleton_data(skeleton_data: np.ndarray, method_to_use='linear', order=3) -> np.ndarray:- """ Takes in a 3d skeleton numpy array from freemocap and interpolates missing NaN values"""- num_frames = skeleton_data.shape[0]- num_markers = skeleton_data.shape[1]-- freemocap_interpolated_data = np.empty((num_frames, num_markers, 3))-- for marker in range(num_markers):- this_marker_skel3d_data = skeleton_data[:, marker, :]- df = pd.DataFrame(this_marker_skel3d_data)- df2 = df.interpolate(method=method_to_use, axis=0,- order=order) # use pandas interpolation methods to fill in missing data- # df.interpolate(method=method_to_use, order = 5)- this_marker_interpolated_skel3d_array = np.array(df2)- # replace the remaining NaN values (the ones that often happen at the start of the recording)- this_marker_interpolated_skel3d_array = np.where(np.isfinite(this_marker_interpolated_skel3d_array),- this_marker_interpolated_skel3d_array,- np.nanmean(this_marker_interpolated_skel3d_array))-- freemocap_interpolated_data[:, marker, :] = this_marker_interpolated_skel3d_array-- return freemocap_interpolated_data---def skellyforge_data(raw_charuco_data: np.ndarray):- interpolated_data = interpolate_skeleton_data(- skeleton_data=raw_charuco_data- )- return interpolated_datadiff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/charuco_observation_aggregator.py b/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/charuco_observation_aggregator.pydeleted file mode 100644index 8ad97cb4..00000000--- a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/charuco_observation_aggregator.py+++ /dev/null@@ -1,388 +0,0 @@-import logging-from pathlib import Path--import cv2-import numpy as np-from pydantic import BaseModel, Field-from skellycam.core.types.type_overloads import CameraIdString-from skellytracker.trackers.charuco_tracker.charuco_observation import CharucoObservation--from freemocap.core.pipeline.pipeline_configs import CalibrationpipelineConfig-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.freemocap_anipose import \- AniposeCameraGroup, AniposeCharucoBoard, AniposeCamera-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.point_triangulator import PointTriangulator-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.charuco_groundplane_utils import \- interpolate_skeleton_data, find_good_frame, CharucoVisibilityError, CharucoVelocityError, \- compute_basis_vectors_of_new_reference, skellyforge_data-from freemocap.core.pipeline.posthoc_pipelines.posthoc_mocap_pipeline.mocap_helpers.charuco_model_from_observations import \- charuco_model_from_observations-from freemocap.core.pipeline.posthoc_pipelines.video_helper import VideoMetadata-from freemocap.core.types.type_overloads import VideoIdString--from freemocap.system.default_paths import get_default_freemocap_base_folder_path--from skellycam.core.recorders.videos.recording_info import RecordingInfo-from skellytracker.trackers.base_tracker.base_tracker_abcs import BaseRecorder--from skellyforge.skellymodels.managers.board import Board-logger = logging.getLogger(__name__)--CharucoObservations = dict[CameraIdString, CharucoObservation | None]---def get_calibrations_folder_path() -> Path:- """Get the main calibrations folder path."""- return Path(get_default_freemocap_base_folder_path()) / "calibrations"---def create_camera_calibration_file_name(recording_name: str) -> str:- """Create a standardized camera calibration filename."""- return f"{recording_name}_camera_calibration.toml"--LAST_SUCCESSFUL_CAMERA_CALIBRATION_STRING = "last_successful_camera_calibration"-def get_last_successful_calibration_toml_path() -> Path:- """Get the path for the last successful calibration TOML file."""- return get_calibrations_folder_path() / f"{LAST_SUCCESSFUL_CAMERA_CALIBRATION_STRING}.toml"----class CharucoObservationAggregator(BaseModel):- anipose_camera_ordering: list[CameraIdString]- # anipose handles camera rows by the ordering of cameras in CameraGroup - so we need to use that ordering when we pass the camera rows to anipose- individual_camera_rows: dict[CameraIdString, list] = Field(default_factory=dict)- @classmethod- def from_charuco_observation_payload(cls,- charuco_observations_by_camera: CharucoObservations,- anipose_camera_ordering: list[CameraIdString]):- if set(charuco_observations_by_camera.keys()) != set(anipose_camera_ordering):- raise ValueError("individual_camera_rows and anipose_camera_ordering must have the same camera ids")- camera_rows = {}- nan_row: list = []- for camera_id, charuco_observation in charuco_observations_by_camera.items():- if charuco_observation is None:- raise ValueError("Cannot create CharucoObservationAggregator from payload with None observations - should use nan-filled CharucoObservation instead")- anipose_camera_row = charuco_observation.to_anipose_camera_row()- if anipose_camera_row is None:- raise ValueError("Cannot create CharucoObservationAggregator from payload with None observations - should use nan-filled CharucoObservation instead")- camera_rows[camera_id] = [anipose_camera_row]-- return cls(individual_camera_rows=camera_rows, anipose_camera_ordering=anipose_camera_ordering)-- @property- def all_camera_rows(self):- return [self.individual_camera_rows[anipose_camera_id] for anipose_camera_id in self.anipose_camera_ordering]-- def add_observations(self, charuco_observations_by_camera: CharucoObservations):- for camera_id, charuco_observation in charuco_observations_by_camera.items():- if charuco_observation is None:- raise ValueError("Cannot add None observations to CharucoObservationAggregator - should use nan-filled CharucoObservation instead")- anipose_camera_row = charuco_observation.to_anipose_camera_row()- if anipose_camera_row is None:- raise ValueError("Cannot add None observations to CharucoObservationAggregator - should use nan-filled CharucoObservation instead")- self.individual_camera_rows[camera_id].append(anipose_camera_row)---class GroundPlaneSuccess:- def __init__(self, success: bool, error: str | None = None):- self.success = success- self.error = error---def anipose_calibration_from_charuco_observations(- charuco_observations_by_frame: list[dict[CameraIdString, CharucoObservation]],- calibration_pipeline_config:CalibrationpipelineConfig,- video_metadata: dict[VideoIdString, VideoMetadata],- recording_info: RecordingInfo,- pin_camera_0_to_origin: bool = True,- use_charuco_as_groundplane: bool = False,- init_intrinsics: bool = True,- init_extrinsics: bool = True,- verbose: bool = True, ) -> Path:-- anipose_cameras: list[AniposeCamera] = [- AniposeCamera(name=video_id,- size=(video_metadata.height, video_metadata.width)) for video_id, video_metadata in- video_metadata.items()- ]- anipose_camera_group = AniposeCameraGroup(cameras=anipose_cameras)-- anipose_charuco_board = AniposeCharucoBoard(squaresX=calibration_pipeline_config.charuco_board_x_squares,- squaresY=calibration_pipeline_config.charuco_board_y_squares,- square_length=calibration_pipeline_config.charuco_square_length,- marker_length=calibration_pipeline_config.charuco_square_length * .8)- logger.info(- f"Starting Anipose calibration with {len(charuco_observations_by_frame)} frames of charuco observations")- # Aggregate all observations-- charuco_observation_aggregator: CharucoObservationAggregator | None = None- for charuco_observations_by_camera in charuco_observations_by_frame:- if charuco_observation_aggregator is None:- charuco_observation_aggregator = CharucoObservationAggregator.from_charuco_observation_payload(- charuco_observations_by_camera=charuco_observations_by_camera,- anipose_camera_ordering=[camera.name for camera in anipose_camera_group.cameras]- )- charuco_observation_aggregator.add_observations(charuco_observations_by_camera)-- if charuco_observation_aggregator is None:- raise ValueError("No charuco observations were provided for calibration")-- # Perform calibration on aggregated rows- all_camera_rows = charuco_observation_aggregator.all_camera_rows- logger.info(f"Aggregated charuco observations for {len(all_camera_rows)} cameras")- error, merged, charuco_frame_numbers = anipose_camera_group.calibrate_rows(- all_camera_rows,- anipose_charuco_board,- init_intrinsics=init_intrinsics,- init_extrinsics=init_extrinsics,- verbose=verbose,- )-- logger.info(f"Anipose calibration completed successfully!")-- logger.info(f"Calibration error: {error}")-- # Add metadata- anipose_camera_group.metadata["groundplane_calibration"] = False- anipose_camera_group.metadata["recording_info"] = recording_info.model_dump()--- groundplane_success: GroundPlaneSuccess | None = None-- # Apply camera 0 pinning if requested- if pin_camera_0_to_origin:- anipose_camera_group = pin_camera_zero_to_origin(camera_group=anipose_camera_group)- logger.info("Pinned camera 0 to origin")-- # Apply groundplane correction if requested- if use_charuco_as_groundplane:- observation_recorders_by_video = {video_id: BaseRecorder() for video_id in- charuco_observations_by_frame[0].keys()}- for frame_number, charuco_observations_by_camera in enumerate(charuco_observations_by_frame):- if not all(- [isinstance(output, CharucoObservation) for output in charuco_observations_by_camera.values()]):- raise ValueError(- f"Non-CharucoObservation found in frame {frame_number} observations: {charuco_observations_by_camera}")- for video_id, recorder in observation_recorders_by_video.items():- recorder.add_observation(observation=charuco_observations_by_camera[video_id])--- anipose_camera_group, groundplane_success = set_charuco_board_as_groundplane(- observation_recorders=observation_recorders_by_video,- anipose_camera_group=anipose_camera_group,- anipose_charuco_board=anipose_charuco_board,- recording_folder_path=Path(recording_info.full_recording_path)- )- if groundplane_success.success:- anipose_camera_group.metadata["groundplane_calibration"] = True- logger.info("Successfully set charuco board as groundplane")- else:- logger.warning(f"Failed to set groundplane: {groundplane_success.error}")-- # Calculate real-world camera positions and orientations- get_real_world_matrices(camera_group=anipose_camera_group)-- # Create calibration filename- calibration_file_name = create_camera_calibration_file_name(recording_name=recording_info.recording_name)-- # Save to recording folder- recording_folder_calibration_toml_path = Path(recording_info.full_recording_path)/calibration_file_name- anipose_camera_group.dump(recording_folder_calibration_toml_path)- logger.info(f"Saved calibration to: {recording_folder_calibration_toml_path}")-- # Save to main calibrations folder- calibration_folder_calibration_toml_path = Path(get_calibrations_folder_path()) / calibration_file_name- anipose_camera_group.dump(calibration_folder_calibration_toml_path)- logger.info(f"Saved calibration to: {calibration_folder_calibration_toml_path}")-- # Save as last successful calibration- anipose_camera_group.dump(get_last_successful_calibration_toml_path())- logger.info(f"Saved as last successful calibration: {get_last_successful_calibration_toml_path()}")- return recording_folder_calibration_toml_path---def pin_camera_zero_to_origin(camera_group: AniposeCameraGroup) -> AniposeCameraGroup:- """- Re-express all camera extrinsics relative to camera 0.-- This function performs two operations:- 1. Rotates all camera coordinate systems so that camera 0's orientation becomes the new world frame.- 2. Shifts the world origin to camera 0's position, making it the new coordinate origin (0, 0, 0).-- The result is that:- - Camera 0 ends up with an identity rotation and zero translation.- - All other cameras are expressed relative to camera 0's original position and orientation.- """- rvecs_new = align_rotations_to_cam0(camera_group=camera_group)- camera_group.set_rotations(rvecs_new)- tvecs_new = shift_origin_to_cam0(camera_group=camera_group)- camera_group.set_translations(tvecs_new)- return camera_group---def align_rotations_to_cam0(camera_group: AniposeCameraGroup) -> np.ndarray:- """Align all camera rotations to camera 0's coordinate frame."""- rvecs = camera_group.get_rotations()- R0, _ = cv2.Rodrigues(rvecs[0])-- rvecs_new = np.empty_like(rvecs)- for i in range(rvecs.shape[0]):- Ri, _ = cv2.Rodrigues(rvecs[i])- Ri_new, _ = cv2.Rodrigues(Ri @ R0.T)- rvecs_new[i] = Ri_new.flatten()- return rvecs_new---def shift_origin_to_cam0(camera_group: AniposeCameraGroup) -> np.ndarray:- """Shift world origin to camera 0's position."""- tvecs = camera_group.get_translations()- rvecs = camera_group.get_rotations()-- camera_0_translation = tvecs[0, :]- camera_0_rotation = rvecs[0, :]-- R0, _ = cv2.Rodrigues(camera_0_rotation)- delta_to_origin_world = -R0.T @ camera_0_translation-- new_tvecs = np.zeros_like(tvecs)- for cam_i in range(tvecs.shape[0]):- Ri, _ = cv2.Rodrigues(rvecs[cam_i, :])- delta_to_origin_camera_i = Ri @ delta_to_origin_world- new_tvecs[cam_i, :] = tvecs[cam_i, :] + delta_to_origin_camera_i- return new_tvecs---def set_charuco_board_as_groundplane(- observation_recorders: dict[VideoIdString, BaseRecorder],- anipose_camera_group: AniposeCameraGroup,- anipose_charuco_board: AniposeCharucoBoard,- recording_folder_path: Path | None = None-) -> tuple[AniposeCameraGroup, GroundPlaneSuccess]:- """Set the charuco board plane as the world groundplane."""- logger.info("Getting 2D Charuco data")- data2d_by_video: dict[VideoIdString, np.ndarray] = {}- if len(observation_recorders) == 0:- raise ValueError("No observation recorders provided to process.")-- for video_id, recorder in observation_recorders.items():- if not all([isinstance(observation, CharucoObservation) for observation in recorder.observations]):- raise TypeError(f"Recorder for video ID {video_id} contains non-Charuco observations.")- data2d_fr_id_xyc = recorder.to_array.copy()- logger.info(f"Processing video ID: {video_id} with 2D data shape: {data2d_fr_id_xyc.shape}")- data2d_by_video[video_id] = data2d_fr_id_xyc[..., :2]--- charuco2d_cam_fr_id_xy = np.stack(list(data2d_by_video.values()), axis=0) # shape: (num_cameras, num_frames, num_tracked_points, 2)- if charuco2d_cam_fr_id_xy is None:- error_message = "Charuco 2d data was not retrieved successfully. Check for an error during calibration."- logger.error(error_message)- raise ValueError(error_message)-- logger.info(f"Charuco 2d data retrieved successfully with shape (cams, frames, markers, XY): {charuco2d_cam_fr_id_xy.shape}")- charuco2d_cam_fr_id_xy = charuco2d_cam_fr_id_xy.astype(np.float64)- num_cameras, num_frames, num_tracked_points, _ = charuco2d_cam_fr_id_xy.shape- charuco_2d_flat = charuco2d_cam_fr_id_xy.reshape(num_cameras, -1, 2)-- logger.info("Getting 3d Charuco data")- charuco_3d_flat = anipose_camera_group.triangulate(charuco_2d_flat)- charuco3d_fr_id_xyz = charuco_3d_flat.reshape(num_frames, num_tracked_points, 3)- logger.info(f"Charuco 3d data reconstructed with shape: {charuco3d_fr_id_xyz.shape}")-- charuco_3d_xyz_interpolated = interpolate_skeleton_data(- skeleton_data=charuco3d_fr_id_xyz- )-- try:- charuco_still_frame_idx = find_good_frame(- charuco_data3d_fr_id_xyz=charuco3d_fr_id_xyz,- number_of_squares_width=anipose_charuco_board.squaresX,- number_of_squares_height=anipose_charuco_board.squaresY,- )- except CharucoVisibilityError as e:- logger.warning("Ground-plane alignment skipped — reverting to original calibration: %s", e, exc_info=True)- return anipose_camera_group, GroundPlaneSuccess(success=False, error=str(e))- except CharucoVelocityError as e:- logger.warning("Ground-plane alignment skipped — reverting to original calibration: %s", e, exc_info=True)- return anipose_camera_group, GroundPlaneSuccess(success=False, error=str(e))-- charuco_frame = charuco_3d_xyz_interpolated[charuco_still_frame_idx]-- x_hat, y_hat, z_hat = compute_basis_vectors_of_new_reference(- charuco_frame,- number_of_squares_width=anipose_charuco_board.squaresX,- number_of_squares_height=anipose_charuco_board.squaresY- )-- charuco_origin_in_world = charuco_frame[0]- rmat_charuco_to_world = np.column_stack([x_hat, y_hat, z_hat])-- rvecs_new, tvecs_new = adjust_world_reference_frame_to_charuco(- camera_group=anipose_camera_group,- charuco_origin_in_world=charuco_origin_in_world,- rmat_charuco_to_world=rmat_charuco_to_world- )-- anipose_camera_group.set_rotations(rvecs_new)- anipose_camera_group.set_translations(tvecs_new)-- logger.info("Anipose camera calibration data adjusted to set charuco board as ground plane")-- # Recalculate 3D charuco data in new coordinate system- charuco_3d_flat = anipose_camera_group.triangulate(charuco_2d_flat)- charuco3d_fr_id_xyz = charuco_3d_flat.reshape(num_frames, num_tracked_points, 3)- charuco_3d_xyz_interpolated = skellyforge_data(raw_charuco_data=charuco3d_fr_id_xyz)-- # Save charuco 3D data if recording folder is provided- if recording_folder_path is not None:- charuco_save_path = recording_folder_path / "output_data" / "charuco_3d_xyz.npy"- charuco_save_path.parent.mkdir(parents=True, exist_ok=True)- np.save(charuco_save_path, charuco_3d_xyz_interpolated)- logger.info(f"Charuco 3d data saved to {charuco_save_path}")-- return anipose_camera_group, GroundPlaneSuccess(success=True)---def adjust_world_reference_frame_to_charuco(- camera_group: AniposeCameraGroup,- charuco_origin_in_world: np.ndarray,- rmat_charuco_to_world: np.ndarray-) -> tuple[np.ndarray, np.ndarray]:- """Adjust camera extrinsics to use charuco board as world reference frame."""- tvecs = camera_group.get_translations()- rvecs = camera_group.get_rotations()-- tvecs_new = np.zeros_like(tvecs)- rvecs_new = np.zeros_like(rvecs)-- for i in range(tvecs.shape[0]):- rmat_world_to_cam_i, _ = cv2.Rodrigues(rvecs[i])- t_delta = rmat_world_to_cam_i @ charuco_origin_in_world- tvecs_new[i] = t_delta + tvecs[i]-- new_rmat = rmat_world_to_cam_i @ rmat_charuco_to_world- new_rvec, _ = cv2.Rodrigues(new_rmat)- rvecs_new[i] = new_rvec.flatten()-- return rvecs_new, tvecs_new---def get_real_world_matrices(camera_group: AniposeCameraGroup) -> tuple[list, list]:- """Calculate real-world positions and orientations of cameras."""- rvecs = camera_group.get_rotations()- tvecs = camera_group.get_translations()-- positions = []- orientations = []-- for i in range(tvecs.shape[0]):- rmat_world_to_cam_i, _ = cv2.Rodrigues(rvecs[i])-- rmat_cam_to_world = rmat_world_to_cam_i.T- t_world = -rmat_cam_to_world @ tvecs[i]-- positions.append(t_world.astype(float).tolist())- orientations.append(rmat_cam_to_world.astype(float).tolist())-- camera_group.set_world_positions(positions)- camera_group.set_world_orientations(orientations)-- return positions, orientationsdiff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/freemocap_anipose.py b/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/freemocap_anipose.pydeleted file mode 100644index 512ca5b5..00000000--- a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/freemocap_anipose.py+++ /dev/null@@ -1,2406 +0,0 @@-# Most of this was copied (with permission) from the original `aniposelib` package (https://github.com/lambdaloop/aniposelib), and we're adapting it to our needs here. M-# ore info on Anipoise: https://anipose.readthedocs.io/en/latest/--import itertools-import logging-import multiprocessing-import queue-import time-from collections import defaultdict, Counter-from copy import copy-from pathlib import Path-from typing import List--import cv2-import numpy as np-import toml-from aniposelib.boards import extract_points, extract_rtvecs, get_video_params, merge_rows, CharucoBoard-from aniposelib.utils import get_rtvec, make_M-from numba import jit-from scipy import optimize-from scipy import signal-from scipy.cluster.hierarchy import linkage, fcluster-from scipy.cluster.vq import whiten-from scipy.linalg import inv as inverse-from scipy.sparse import dok_matrix-# from skellytracker.process_folder_of_videos import process_list_of_videos-# from skellytracker.trackers.charuco_tracker.charuco_model_info import CharucoModelInfo, CharucoTrackingParams-from tqdm import trange--numba_logger = logging.getLogger("numba")-numba_logger.setLevel(logging.WARNING)--logger = logging.getLogger(__name__)--ARUCO_DICTS = {- (4, 50): cv2.aruco.DICT_4X4_50,- (5, 50): cv2.aruco.DICT_5X5_50,- (6, 50): cv2.aruco.DICT_6X6_50,- (7, 50): cv2.aruco.DICT_7X7_50,- (4, 100): cv2.aruco.DICT_4X4_100,- (5, 100): cv2.aruco.DICT_5X5_100,- (6, 100): cv2.aruco.DICT_6X6_100,- (7, 100): cv2.aruco.DICT_7X7_100,- (4, 250): cv2.aruco.DICT_4X4_250,- (5, 250): cv2.aruco.DICT_5X5_250,- (6, 250): cv2.aruco.DICT_6X6_250,- (7, 250): cv2.aruco.DICT_7X7_250,- (4, 1000): cv2.aruco.DICT_4X4_1000,- (5, 1000): cv2.aruco.DICT_5X5_1000,- (6, 1000): cv2.aruco.DICT_6X6_1000,- (7, 1000): cv2.aruco.DICT_7X7_1000,-}---# @jit(nopython=True, parallel=False)-def triangulate_simple(points, camera_mats):- num_cams = len(camera_mats)- A = np.zeros((num_cams * 2, 4))- for i in range(num_cams):- x, y = points[i]- mat = camera_mats[i]- A[(i * 2): (i * 2 + 1)] = x * mat[2] - mat[0]- A[(i * 2 + 1): (i * 2 + 2)] = y * mat[2] - mat[1]- u, s, vh = np.linalg.svd(A, full_matrices=True)- p3d = vh[-1]- p3d = p3d[:3] / p3d[3]- return p3d---def get_error_dict(errors_full, min_points=10):- n_cams = errors_full.shape[0]- errors_norm = np.linalg.norm(errors_full, axis=2)-- good = ~np.isnan(errors_full[:, :, 0])-- error_dict = dict()-- for i in range(n_cams):- for j in range(i + 1, n_cams):- subset = good[i] & good[j]- err_subset = errors_norm[:, subset][[i, j]]- err_subset_mean = np.mean(err_subset, axis=0)- if np.sum(subset) > min_points:- percents = np.percentile(err_subset_mean, [15, 75])- # percents = np.percentile(err_subset, [25, 75])- error_dict[(i, j)] = (err_subset.shape[1], percents)- return error_dict---def check_errors(cgroup, imgp):- p3ds = cgroup.triangulate(imgp)- errors_full = cgroup.reprojection_error(p3ds, imgp, mean=False)- return get_error_dict(errors_full)---def subset_extra(extra, ixs):- if extra is None:- return None-- new_extra = {- "objp": extra["objp"][ixs],- "ids": extra["ids"][ixs],- "rvecs": extra["rvecs"][:, ixs],- "tvecs": extra["tvecs"][:, ixs],- }- return new_extra---def resample_points_extra(imgp, extra, n_samp=25):- n_cams, n_points, _ = imgp.shape- ids = remap_ids(extra["ids"])- n_ids = np.max(ids) + 1- good = ~np.isnan(imgp[:, :, 0])- ixs = np.arange(n_points)-- cam_counts = np.zeros((n_ids, n_cams), dtype="int64")- for idnum in range(n_ids):- cam_counts[idnum] = np.sum(good[:, ids == idnum], axis=1)- cam_counts_random = cam_counts + np.random.random(size=cam_counts.shape)- best_boards = np.argsort(-cam_counts_random, axis=0)-- cam_totals = np.zeros(n_cams, dtype="int64")-- include = set()- for cam_num in range(n_cams):- for board_id in best_boards[:, cam_num]:- include.update(ixs[ids == board_id])- cam_totals += cam_counts[board_id]- if cam_totals[cam_num] >= n_samp or cam_counts_random[board_id, cam_num] < 1:- break-- final_ixs = sorted(include)- newp = imgp[:, final_ixs]- extra = subset_extra(extra, final_ixs)- return newp, extra---def resample_points(imgp, extra=None, n_samp=25):- # if extra is not None:- # return resample_points_extra(imgp, extra, n_samp)-- n_cams = imgp.shape[0]- good = ~np.isnan(imgp[:, :, 0])- ixs = np.arange(imgp.shape[1])-- num_cams = np.sum(~np.isnan(imgp[:, :, 0]), axis=0)-- include = set()-- for i in range(n_cams):- for j in range(i + 1, n_cams):- subset = good[i] & good[j]- n_good = np.sum(subset)- if n_good > 0:- ## pick points, prioritizing points seen by more cameras- arr = np.copy(num_cams[subset]).astype("float64")- arr += np.random.random(size=arr.shape)- picked_ix = np.argsort(-arr)[:n_samp]- picked = ixs[subset][picked_ix]- include.update(picked)-- final_ixs = sorted(include)- newp = imgp[:, final_ixs]- extra = subset_extra(extra, final_ixs)- return newp, extra---def medfilt_data(values, size=15):- padsize = size + 5- vpad = np.pad(values, (padsize, padsize), mode="reflect")- vpadf = signal.medfilt(vpad, kernel_size=size)- return vpadf[padsize:-padsize]---def nan_helper(y):- return np.isnan(y), lambda z: z.nonzero()[0]---def interpolate_data(vals):- nans, ix = nan_helper(vals)- out = np.copy(vals)- try:- out[nans] = np.interp(ix(nans), ix(~nans), vals[~nans])- except ValueError:- out[:] = 0- return out---def remap_ids(ids):- unique_ids = np.unique(ids)- ids_out = np.copy(ids)- for i, num in enumerate(unique_ids):- ids_out[ids == num] = i- return ids_out---def transform_points(points, rvecs, tvecs):- """Rotate points by given rotation vectors and translate.- Rodrigues' rotation formula is used.- """- theta = np.linalg.norm(rvecs, axis=1)[:, np.newaxis]- with np.errstate(invalid="ignore"):- v = rvecs / theta- v = np.nan_to_num(v)- dot = np.sum(points * v, axis=1)[:, np.newaxis]- cos_theta = np.cos(theta)- sin_theta = np.sin(theta)-- rotated = cos_theta * points + sin_theta * np.cross(v, points) + dot * (1 - cos_theta) * v-- return rotated + tvecs---def get_connections(xs: np.ndarray, cam_names: list | None = None, both: bool = True) -> dict[tuple, int]:- """Get connection counts between camera pairs."""- from collections import defaultdict-- n_cams = xs.shape[0]- n_points = xs.shape[1]-- if cam_names is None:- cam_names = [str(i) for i in range(n_cams)]-- connections = defaultdict(int)-- for rnum in range(n_points):- ixs = np.where(~np.isnan(xs[:, rnum, 0]))[0]- keys = [cam_names[ix] for ix in ixs]- for i in range(len(keys)):- for j in range(i + 1, len(keys)):- a = keys[i]- b = keys[j]- connections[(a, b)] += 1- if both:- connections[(b, a)] += 1-- return connections---def get_calibration_graph(rtvecs, cam_names=None):- n_cams = rtvecs.shape[0]- n_points = rtvecs.shape[1]-- if cam_names is None:- cam_names = np.arange(n_cams)-- connections = get_connections(rtvecs, np.arange(n_cams))-- components = dict(zip(np.arange(n_cams), range(n_cams)))- edges = set(connections.items())-- graph = defaultdict(list)-- for edgenum in range(n_cams - 1):- if len(edges) == 0:- component_names = dict()- for k, v in list(components.items()):- component_names[cam_names[k]] = v- raise ValueError(- """-Could not build calibration graph.-Some group of cameras could not be paired by simultaneous calibration board detections.-Check which cameras have different group numbers below to see the missing edges.-{}""".format(- component_names- )- )-- (a, b), weight = max(edges, key=lambda x: x[1])- graph[a].append(b)- graph[b].append(a)-- match = components[a]- replace = components[b]- for k, v in components.items():- if match == v:- components[k] = replace-- for e in edges.copy():- (a, b), w = e- if components[a] == components[b]:- edges.remove(e)-- return graph---def find_calibration_pairs(graph, source=None):- pairs = []- explored = set()-- if source is None:- source = sorted(graph.keys())[0]-- q = queue.deque()- q.append(source)-- while len(q) > 0:- item = q.pop()- explored.add(item)-- for new in graph[item]:- if new not in explored:- q.append(new)- pairs.append((item, new))- return pairs---def compute_camera_matrices(rtvecs: np.ndarray, pairs: list[tuple[int, int]]) -> dict[int, np.ndarray]:- """- Compute camera extrinsics from calibration pairs.-- Args:- rtvecs: Rotation/translation vectors- pairs: List of (source, target) camera pairs-- Returns:- Dictionary mapping camera index to 4x4 transformation matrix- """- logger.debug(f"Computing camera matrices for {len(pairs)} pairs")-- extrinsics = dict()- source = pairs[0][0]- extrinsics[source] = np.identity(4)- logger.debug(f"Camera {source} set as origin (identity transform)")-- for i, (a, b) in enumerate(pairs):- logger.debug(f"Pair {i + 1}/{len(pairs)}: Computing transform from {a} to {b}")-- if a not in extrinsics:- logger.error(f"Camera {a} not yet in extrinsics! Pairs may be ordered incorrectly.")- raise ValueError(f"Camera {a} must be computed before camera {b}")-- try:- ext = get_transform(rtvecs, b, a)- extrinsics[b] = np.matmul(ext, extrinsics[a])- logger.debug(f"Camera {b} extrinsics computed successfully")- except Exception as e:- logger.error(f"Failed to compute transform from {a} to {b}: {e}")- raise-- logger.info(f"Computed extrinsics for {len(extrinsics)} cameras")- return extrinsics---def get_transform(rtvecs: np.ndarray, left: int, right: int) -> np.ndarray:- """- Calculate transform between two cameras with improved convergence.- """- logger.debug(f"Computing transform between camera {left} and camera {right}")-- L = []- valid_frames = 0-- for dix in range(rtvecs.shape[1]):- d = rtvecs[:, dix]- good = ~np.isnan(d[:, 0])-- if good[left] and good[right]:- valid_frames += 1- M_left = make_M(d[left, 0:3], d[left, 3:6])- M_right = make_M(d[right, 0:3], d[right, 3:6])- M = np.matmul(M_left, inverse(M_right))- L.append(M)-- logger.info(f"Camera pair ({left}, {right}): Found {valid_frames} frames with valid observations")-- if len(L) == 0:- raise ValueError(f"No valid transformation matrices found between cameras {left} and {right}")-- logger.debug(f"Selecting best matrices from {len(L)} candidates")- L_best = select_matrices(L)- logger.info(f"Selected {len(L_best)} matrices after clustering (removed {len(L) - len(L_best)} outliers)")-- logger.debug("Computing initial mean transform")- M_mean = mean_transform(L_best)-- # Progressive refinement with decreasing thresholds- # Start more permissive and gradually tighten- thresholds = [0.5, 0.3, 0.15, 0.1]-- for i, error_threshold in enumerate(thresholds):- logger.debug(f"Robust refinement {i + 1}/{len(thresholds)} with error threshold {error_threshold}")-- M_mean_new = mean_transform_robust(- L,- M_mean,- error=error_threshold,- max_iterations=3,- convergence_threshold=0.001- )-- # Check if transform changed significantly- diff = np.max(np.abs(M_mean_new - M_mean))- logger.debug(f"Transform difference after refinement: {diff:.6f}")-- # If change is too large, refinement may be unstable - use previous result- if diff > 10.0: # ~10 radians or 10mm is likely unstable- logger.warning(f"Large transform change ({diff:.2f}) detected, refinement may be unstable")- logger.warning(f"Stopping refinement and using previous result")- break-- M_mean = M_mean_new-- logger.info(f"Final transform computed for camera pair ({left}, {right})")- return M_mean---def get_most_common(vals):- Z = linkage(whiten(vals), "ward")- n_clust = max(len(vals) / 10, 3)- clusts = fcluster(Z, t=n_clust, criterion="maxclust")- cc = Counter(clusts[clusts >= 0])- most = cc.most_common(n=1)- top = most[0][0]- good = clusts == top- return good---def select_matrices(Ms):- Ms = np.array(Ms)- rvecs = [cv2.Rodrigues(M[:3, :3])[0][:, 0] for M in Ms]- tvecs = np.array([M[:3, 3] for M in Ms])- best = get_most_common(np.hstack([rvecs, tvecs]))- Ms_best = Ms[best]- return Ms_best---def mean_transform(M_list: list[np.ndarray]) -> np.ndarray:- """- Compute mean transformation from list of transformation matrices.-- Args:- M_list: List of 4x4 transformation matrices-- Returns:- Mean transformation matrix- """- if len(M_list) == 0:- raise ValueError("Cannot compute mean transform from empty matrix list")-- logger.debug(f"Computing mean of {len(M_list)} transformation matrices")-- rvecs = []- tvecs = []-- for i, M in enumerate(M_list):- try:- rvec = cv2.Rodrigues(M[:3, :3])[0][:, 0]- tvec = M[:3, 3]-- # Validate shapes- if rvec.shape != (3,):- logger.error(f"Matrix {i}: Invalid rvec shape {rvec.shape}, expected (3,)")- continue- if tvec.shape != (3,):- logger.error(f"Matrix {i}: Invalid tvec shape {tvec.shape}, expected (3,)")- continue-- rvecs.append(rvec)- tvecs.append(tvec)-- except Exception as e:- logger.warning(f"Matrix {i}: Failed to extract rvec/tvec - {e}")- continue-- if len(rvecs) == 0:- raise ValueError("No valid rvecs could be extracted from transformation matrices")-- rvec = np.mean(rvecs, axis=0)- tvec = np.mean(tvecs, axis=0)-- # Final validation- if rvec.shape != (3,):- raise ValueError(f"Invalid mean rvec shape {rvec.shape}, expected (3,). Input had {len(rvecs)} valid vectors")- if tvec.shape != (3,):- raise ValueError(f"Invalid mean tvec shape {tvec.shape}, expected (3,). Input had {len(tvecs)} valid vectors")-- # Check for NaN- if np.any(np.isnan(rvec)):- logger.error(f"NaN in mean rvec: {rvec}")- raise ValueError("Mean rvec contains NaN values")- if np.any(np.isnan(tvec)):- logger.error(f"NaN in mean tvec: {tvec}")- raise ValueError("Mean tvec contains NaN values")-- logger.debug(f"Mean rvec: {rvec}, mean tvec: {tvec}")-- return make_M(rvec, tvec)---def mean_transform_robust(- M_list: list[np.ndarray],- approx: np.ndarray | None = None,- error: float = 0.3,- max_iterations: int = 5,- convergence_threshold: float = 0.01-) -> np.ndarray:- """- Compute robust mean by iteratively filtering outliers.-- Args:- M_list: List of transformation matrices- approx: Initial approximation for comparison- error: Maximum acceptable rotation error- max_iterations: Maximum refinement iterations- convergence_threshold: Stop if change is below this threshold-- Returns:- Robust mean transformation- """- if len(M_list) == 0:- raise ValueError("Cannot compute robust mean from empty matrix list")-- if approx is None:- logger.debug("No approximation provided, using all matrices")- return mean_transform(M_list)-- logger.debug(f"Filtering matrices with error threshold {error}")- M_current = approx-- for iteration in range(max_iterations):- M_list_robust = []- errors = []-- for i, M in enumerate(M_list):- rot_error = (M - M_current)[:3, :3]- m = np.max(np.abs(rot_error))- errors.append(m)-- if m < error:- M_list_robust.append(M)-- logger.info(f"Iteration {iteration + 1}: Kept {len(M_list_robust)}/{len(M_list)} matrices")-- if len(errors) > 0:- logger.debug(f"Error statistics: min={min(errors):.6f}, max={max(errors):.6f}, mean={np.mean(errors):.6f}")-- # CRITICAL: If all matrices filtered out, use relaxed threshold- if len(M_list_robust) == 0:- logger.warning(f"All matrices filtered with threshold {error}. Relaxing to use best 50%")- # Use top 50% of matrices by error- sorted_indices = np.argsort(errors)- n_keep = max(len(M_list) // 2, 3) # Keep at least 3 or 50%- M_list_robust = [M_list[i] for i in sorted_indices[:n_keep]]- logger.info(f"Using {len(M_list_robust)} best matrices after relaxation")-- # Compute new mean- M_new = mean_transform(M_list_robust)-- # Check convergence- diff = np.max(np.abs(M_new - M_current))- logger.debug(f"Transform difference: {diff:.6f}")-- if diff < convergence_threshold or iteration == max_iterations - 1:- logger.info(f"Converged after {iteration + 1} iterations (diff={diff:.6f})")- return M_new-- M_current = M_new-- logger.warning(f"Did not converge after {max_iterations} iterations. Using last result.")- return M_current---def get_initial_extrinsics(rtvecs: np.ndarray, cam_names: list | None = None) -> tuple[np.ndarray, np.ndarray]:- """- Compute initial camera extrinsics from pose observations.-- Args:- rtvecs: Array of rotation/translation vectors (n_cams, n_frames, 6)- cam_names: Optional camera names for logging-- Returns:- Tuple of (rvecs, tvecs) for all cameras- """- n_cams = rtvecs.shape[0]- n_frames = rtvecs.shape[1]-- logger.info(f"Computing initial extrinsics for {n_cams} cameras from {n_frames} frames")-- # Log observation statistics- for cam_idx in range(n_cams):- valid_obs = np.sum(~np.isnan(rtvecs[cam_idx, :, 0]))- cam_name = cam_names[cam_idx] if cam_names else str(cam_idx)- logger.info(f"Camera {cam_name}: {valid_obs}/{n_frames} valid observations ({100 * valid_obs / n_frames:.1f}%)")-- logger.debug("Building calibration graph from camera connections")- graph = get_calibration_graph(rtvecs, cam_names)- logger.info(f"Calibration graph: {dict(graph)}")-- logger.debug("Finding calibration pairs")- pairs = find_calibration_pairs(graph, source=0)- logger.info(f"Calibration pairs: {pairs}")-- if len(pairs) != n_cams - 1:- logger.error(f"Expected {n_cams - 1} pairs, got {len(pairs)}. Graph may be disconnected!")-- logger.debug("Computing camera transformation matrices")- extrinsics = compute_camera_matrices(rtvecs, pairs)-- # Extract rvecs and tvecs- rvecs = []- tvecs = []- for cnum in range(n_cams):- cam_name = cam_names[cnum] if cam_names else str(cnum)-- if cnum not in extrinsics:- logger.error(f"Camera {cam_name} (index {cnum}) not in extrinsics dict!")- raise ValueError(f"Missing extrinsics for camera {cnum}")-- try:- rvec, tvec = get_rtvec(extrinsics[cnum])- logger.debug(f"Camera {cam_name}: rvec={rvec}, tvec={tvec}")- rvecs.append(rvec)- tvecs.append(tvec)- except Exception as e:- logger.error(f"Camera {cam_name}: Failed to extract rvec/tvec - {e}")- raise-- rvecs = np.array(rvecs)- tvecs = np.array(tvecs)-- logger.info(f"Successfully computed extrinsics: rvecs shape={rvecs.shape}, tvecs shape={tvecs.shape}")-- # Log summary statistics- rvec_norms = np.linalg.norm(rvecs, axis=1)- tvec_norms = np.linalg.norm(tvecs, axis=1)- logger.info(f"Rotation magnitudes: {rvec_norms}")- logger.info(f"Translation magnitudes: {tvec_norms}")-- return rvecs, tvecs---class AniposeCamera:- def __init__(- self,- matrix=np.eye(3),- dist=np.zeros(5),- size=None,- rvec=np.zeros(3),- tvec=np.zeros(3),- world_orientation=np.eye(3),- world_position=np.zeros(3),- name=None,- extra_dist=False,- ):- self.set_camera_matrix(matrix)- self.set_distortions(dist)- self.set_size(size)- self.set_rotation(rvec)- self.set_translation(tvec)- self.set_world_orientation(world_orientation)- self.set_world_position(world_position)- self.set_name(name)- self.extra_dist = extra_dist-- def get_dict(self):- return {- "name": self.get_name(),- "size": list(self.get_size()),- "matrix": self.get_camera_matrix().tolist(),- "distortions": self.get_distortions().tolist(),- "rotation": self.get_rotation().tolist(),- "translation": self.get_translation().tolist(),- "world_orientation": self.get_world_orientation().tolist(),- "world_position": self.get_world_position().tolist()- }-- def load_dict(self, d):- self.set_camera_matrix(d["matrix"])- self.set_rotation(d["rotation"])- self.set_translation(d["translation"])- self.set_distortions(d["distortions"])- self.set_name(d["name"])- self.set_size(d["size"])-- self.set_world_orientation(d.get("world_orientation", np.eye(3)))- self.set_world_position(d.get("world_position", np.zeros(3)))-- def from_dict(d):- cam = AniposeCamera()- cam.load_dict(d)- return cam-- def get_camera_matrix(self):- return self.matrix-- def get_distortions(self):- return self.dist-- def set_camera_matrix(self, matrix):- self.matrix = np.array(matrix, dtype="float64")-- def set_focal_length(self, fx, fy=None):- if fy is None:- fy = fx- self.matrix[0, 0] = fx- self.matrix[1, 1] = fy-- def get_focal_length(self, both=False):- fx = self.matrix[0, 0]- fy = self.matrix[1, 1]- if both:- return (fx, fy)- else:- return (fx + fy) / 2.0-- def set_distortions(self, dist):- self.dist = np.array(dist, dtype="float64").ravel()-- def set_rotation(self, rvec):- self.rvec = np.array(rvec, dtype="float64").ravel()-- def get_rotation(self):- return self.rvec-- def set_translation(self, tvec):- self.tvec = np.array(tvec, dtype="float64").ravel()-- def get_translation(self):- return self.tvec-- def set_world_orientation(self, world_orientation):- self.world_orientation = np.asarray(world_orientation, dtype="float64").reshape(3, 3)-- def get_world_orientation(self):- return self.world_orientation-- def set_world_position(self, world_position):- self.world_position = np.array(world_position, dtype="float64").ravel()-- def get_world_position(self):- return self.world_position-- def get_extrinsics_mat(self):- return make_M(self.rvec, self.tvec)-- def get_name(self):- return self.name-- def set_name(self, name):- self.name = str(name)-- def set_size(self, size):- """set size as (width, height)"""- self.size = size-- def get_size(self):- """get size as (width, height)"""- return self.size-- def resize_camera(self, scale):- """resize the camera by scale factor, updating intrinsics to match"""- size = self.get_size()- new_size = size[0] * scale, size[1] * scale- matrix = self.get_camera_matrix()- new_matrix = matrix * scale- new_matrix[2, 2] = 1- self.set_size(new_size)- self.set_camera_matrix(new_matrix)-- def get_params(self):- params = np.zeros(8 + self.extra_dist, dtype="float64")- params[0:3] = self.get_rotation()- params[3:6] = self.get_translation()- params[6] = self.get_focal_length()- dist = self.get_distortions()- params[7] = dist[0]- if self.extra_dist:- params[8] = dist[1]- return params-- def set_params(self, params):- self.set_rotation(params[0:3])- self.set_translation(params[3:6])- self.set_focal_length(params[6])-- dist = np.zeros(5, dtype="float64")- dist[0] = params[7]- if self.extra_dist:- dist[1] = params[8]- self.set_distortions(dist)-- def distort_points(self, points):- shape = points.shape- points = points.reshape(-1, 1, 2)- new_points = np.dstack([points, np.ones((points.shape[0], 1, 1))])- out, _ = cv2.projectPoints(- new_points,- np.zeros(3),- np.zeros(3),- self.matrix.astype("float64"),- self.dist.astype("float64"),- )- return out.reshape(shape)-- def undistort_points(self, points):- shape = points.shape- points = points.reshape(-1, 1, 2)- out = cv2.undistortPoints(points, self.matrix.astype("float64"), self.dist.astype("float64"))- return out.reshape(shape)-- def project(self, points):- points = points.reshape(-1, 1, 3)- out, _ = cv2.projectPoints(- points,- self.rvec,- self.tvec,- self.matrix.astype("float64"),- self.dist.astype("float64"),- )- return out-- def single_camera_reprojection_error(self, p3d, p2d):- projecting_3d_points_onto_2d_image_plane_og = self.project(p3d)- projecting_3d_points_onto_2d_image_plane = projecting_3d_points_onto_2d_image_plane_og.reshape(p2d.shape)- return p2d - projecting_3d_points_onto_2d_image_plane-- def copy(self):- return AniposeCamera(- matrix=self.get_camera_matrix().copy(),- dist=self.get_distortions().copy(),- size=self.get_size(),- rvec=self.get_rotation().copy(),- tvec=self.get_translation().copy(),- name=self.get_name(),- extra_dist=self.extra_dist,- world_orientation=self.get_world_orientation().copy(),- world_position=self.get_world_position().copy()- )----class AniposeCameraGroup:- def __init__(self, cameras:list[AniposeCamera], metadata={}):- self.cameras = cameras- self.metadata = metadata- self.charuco_2d_data = None-- def subset_cameras(self, indices):- cams = [self.cameras[ix].copy() for ix in indices]- return AniposeCameraGroup(cams, self.metadata)-- def subset_cameras_names(self, names):- cur_names = self.get_names()- cur_names_dict = dict(zip(cur_names, range(len(cur_names))))- indices = []- for name in names:- if name not in cur_names_dict:- raise IndexError("name {} not part of camera names: {}".format(name, cur_names))- indices.append(cur_names_dict[name])- return self.subset_cameras(indices)-- def project(self, points):- """Given an Nx3 array of points, this returns an CxNx2 array of 2D points,- where C is the number of cameras"""- points = points.reshape(-1, 1, 3)- n_points = points.shape[0]- n_cams = len(self.cameras)-- out = np.empty((n_cams, n_points, 2), dtype="float64")- for cnum, cam in enumerate(self.cameras):- out[cnum] = cam.project(points).reshape(n_points, 2)-- return out-- def triangulate(self, points, undistort=True, progress=False, kill_event: multiprocessing.Event = None):- """Given an CxNx2 array, this returns an Nx3 array of points,- where N is the number of points and C is the number of cameras"""-- assert points.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), points.shape- )-- one_point = False- if len(points.shape) == 2:- points = points.reshape(-1, 1, 2)- one_point = True-- if undistort:- new_points = np.empty(points.shape)- for cnum, cam in enumerate(self.cameras):- # must copy in order to satisfy opencv underneath- sub = np.copy(points[cnum])- new_points[cnum] = cam.undistort_points(sub)- points = new_points-- n_cams, n_points, _ = points.shape-- out = np.empty((n_points, 3))- out[:] = np.nan-- cam_mats = np.array([cam.get_extrinsics_mat() for cam in self.cameras])-- if progress:- iterator = trange(n_points, ncols=70)- else:- iterator = range(n_points)-- for ip in iterator:- subp = points[:, ip, :]- good = ~np.isnan(subp[:, 0])- if np.sum(good) >= 2:- out[ip] = triangulate_simple(subp[good], cam_mats[good])-- if kill_event is not None and kill_event.is_set():- return None-- if one_point:- out = out[0]-- return out-- def triangulate_possible(- self,- points,- undistort=True,- min_cams=2,- progress=False,- threshold=0.5,- kill_event: multiprocessing.Event = None,- ):- """Given an CxNxPx2 array, this returns an Nx3 array of points- by triangulating all possible points and picking the ones with- best reprojection error- where:- C: number of cameras- N: number of points- P: number of possible options per point- """-- assert points.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), points.shape- )-- n_cams, n_points, n_possible, _ = points.shape-- cam_nums, point_nums, possible_nums = np.where(~np.isnan(points[:, :, :, 0]))-- all_iters = defaultdict(dict)-- for cam_num, point_num, possible_num in zip(cam_nums, point_nums, possible_nums):- if cam_num not in all_iters[point_num]:- all_iters[point_num][cam_num] = []- all_iters[point_num][cam_num].append((cam_num, possible_num))-- for point_num in all_iters.keys():- for cam_num in all_iters[point_num].keys():- all_iters[point_num][cam_num].append(None)-- out = np.full((n_points, 3), np.nan, dtype="float64")- picked_vals = np.zeros((n_cams, n_points, n_possible), dtype="bool")- errors = np.zeros(n_points, dtype="float64")- points_2d = np.full((n_cams, n_points, 2), np.nan, dtype="float64")-- if progress:- iterator = trange(n_points, ncols=70)- else:- iterator = range(n_points)-- for point_ix in iterator:- best_point = None- best_error = 200-- n_cams_max = len(all_iters[point_ix])-- for picked in itertools.product(*all_iters[point_ix].values()):- picked = [p for p in picked if p is not None]- if len(picked) < min_cams and len(picked) != n_cams_max:- continue-- if kill_event is not None and kill_event.is_set():- return None-- cnums = [p[0] for p in picked]- xnums = [p[1] for p in picked]-- pts = points[cnums, point_ix, xnums]- cc = self.subset_cameras(cnums)-- p3d = cc.triangulate(pts, undistort=undistort)- err = cc.reprojection_error(p3d, pts, mean=True)-- if err < best_error:- best_point = {- "error": err,- "point": p3d[:3],- "points": pts,- "picked": picked,- "joint_ix": point_ix,- }- best_error = err- if best_error < threshold:- break-- if best_point is not None:- out[point_ix] = best_point["point"]- picked = best_point["picked"]- cnums = [p[0] for p in picked]- xnums = [p[1] for p in picked]- picked_vals[cnums, point_ix, xnums] = True- errors[point_ix] = best_point["error"]- points_2d[cnums, point_ix] = best_point["points"]-- # return out, picked_vals, points_2d, errors #original code from OG anipose- return out # simplify output so that `triangulate_ransac` can be used exactly the same way as `triangulate`-- def triangulate_ransac(- self, points, undistort=True, min_cams=2, progress=False, kill_event: multiprocessing.Event = None- ):- """Given an CxNx2 array, this returns an Nx3 array of points,- where N is the number of points and C is the number of cameras"""-- assert points.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), points.shape- )-- n_cams, n_points, _ = points.shape-- points_ransac = points.reshape(n_cams, n_points, 1, 2)-- return self.triangulate_possible(- points_ransac, undistort=undistort, min_cams=min_cams, progress=progress, kill_event=kill_event- )-- @jit(parallel=True, forceobj=True)- def reprojection_error(self, points_3d, points_2d, mean=False):- """Given an Nx3 array of 3D points and an CxNx2 array of 2D points,- where N is the number of points and C is the number of cameras,- this returns an CxNx2 array of errors.- Optionally mean=True, this averages the errors and returns array of length N of errors"""-- one_point = False- if len(points_3d.shape) == 1 and len(points_2d.shape) == 2:- points_3d = points_3d.reshape(1, 3)- points_2d = points_2d.reshape(-1, 1, 2)- one_point = True-- n_cams, n_points, _ = points_2d.shape- assert points_3d.shape == (- n_points,- 3,- ), "shapes of 2D and 3D points are not consistent: " "2D={}, 3D={}".format(points_2d.shape, points_3d.shape)-- errors = np.empty((n_cams, n_points, 2))-- for camera_number, cam in enumerate(self.cameras):- errors[camera_number] = cam.single_camera_reprojection_error(points_3d, points_2d[camera_number])-- if mean:- errors_norm = np.linalg.norm(errors, axis=2)- good = ~np.isnan(errors_norm)- errors_norm[~good] = 0- denom = np.sum(good, axis=0).astype("float64")- denom[denom < 1.5] = np.nan- errors = np.sum(errors_norm, axis=0) / denom-- if one_point:- if mean:- errors = float(errors[0])- else:- errors = errors.reshape(-1, 2)-- return errors-- def bundle_adjust_iter(- self,- p2ds,- extra=None,- n_iters=10,- start_mu=15,- end_mu=1,- max_nfev=200,- ftol=1e-4,- n_samp_iter=100,- n_samp_full=1000,- error_threshold=0.3,- verbose=False,- ):- """Given an CxNx2 array of 2D points,- where N is the number of points and C is the number of cameras,- this performs iterative bundle adjustsment to fine-tune the parameters of the cameras.- That is, it performs bundle adjustment multiple times, adjusting the weights given to points- to reduce the influence of outliers.- This is inspired by the algorithm for Fast Global Registration by Zhou, Park, and Koltun- """- error_list = []-- assert p2ds.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), p2ds.shape- )-- p2ds_full = p2ds- extra_full = extra-- p2ds, extra = resample_points(p2ds_full, extra_full, n_samp=n_samp_full)- error = self.average_error(p2ds, median=True)-- if verbose:- print("error: ", error)-- mus = np.exp(np.linspace(np.log(start_mu), np.log(end_mu), num=n_iters))-- if verbose:- print("n_samples: {}".format(n_samp_iter))-- for i in range(n_iters):- p2ds, extra = resample_points(p2ds_full, extra_full, n_samp=n_samp_full)- p3ds = self.triangulate(p2ds)- errors_full = self.reprojection_error(p3ds, p2ds, mean=False)- errors_norm = self.reprojection_error(p3ds, p2ds, mean=True)-- error_dict = get_error_dict(errors_full)- max_error = 0- min_error = 0- for k, v in error_dict.items():- num, percents = v- max_error = max(percents[-1], max_error)- min_error = max(percents[0], min_error)- mu = max(min(max_error, mus[i]), min_error)-- good = errors_norm < mu- extra_good = subset_extra(extra, good)- p2ds_samp, extra_samp = resample_points(p2ds[:, good], extra_good, n_samp=n_samp_iter)-- error = np.median(errors_norm)- error_list.append(error)-- if error < error_threshold:- break-- if verbose:- print(error_dict)- print("error: {:.2f}, mu: {:.1f}, ratio: {:.3f}".format(error, mu, np.mean(good)))- print(f"previous error scores: [magenta] {error_list}[/magenta]")-- self.bundle_adjust(- p2ds_samp,- extra_samp,- loss="linear",- ftol=ftol,- max_nfev=max_nfev,- verbose=verbose,- )-- p2ds, extra = resample_points(p2ds_full, extra_full, n_samp=n_samp_full)- p3ds = self.triangulate(p2ds)- errors_full = self.reprojection_error(p3ds, p2ds, mean=False)- errors_norm = self.reprojection_error(p3ds, p2ds, mean=True)- error_dict = get_error_dict(errors_full)- if verbose:- print(error_dict)-- max_error = 0- min_error = 0- for k, v in error_dict.items():- num, percents = v- max_error = max(percents[-1], max_error)- min_error = max(percents[0], min_error)- mu = max(max(max_error, end_mu), min_error)-- good = errors_norm < mu- extra_good = subset_extra(extra, good)- self.bundle_adjust(- p2ds[:, good],- extra_good,- loss="linear",- ftol=ftol,- max_nfev=max(200, max_nfev),- verbose=verbose,- )-- error = self.average_error(p2ds, median=True)-- p3ds = self.triangulate(p2ds)- errors_full = self.reprojection_error(p3ds, p2ds, mean=False)- error_dict = get_error_dict(errors_full)- if verbose:- print(error_dict)-- if verbose:- print("error: ", error)-- return error-- def bundle_adjust(- self,- p2ds,- extra=None,- loss="linear",- threshold=50,- ftol=1e-4,- max_nfev=1000,- weights=None,- start_params=None,- verbose=True,- ):- """Given an CxNx2 array of 2D points,- where N is the number of points and C is the number of cameras,- this performs bundle adjustsment to fine-tune the parameters of the cameras"""-- assert p2ds.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), p2ds.shape- )-- if extra is not None:- extra["ids_map"] = remap_ids(extra["ids"])-- x0, n_cam_params = self._initialize_params_bundle(p2ds, extra)-- if start_params is not None:- x0 = start_params- n_cam_params = len(self.cameras[0].get_params())-- error_fun = self._error_fun_bundle-- jac_sparse = self._jac_sparsity_bundle(p2ds, n_cam_params, extra)-- f_scale = threshold- opt = optimize.least_squares(- error_fun,- x0,- jac_sparsity=jac_sparse,- f_scale=f_scale,- x_scale="jac",- loss=loss,- ftol=ftol,- method="trf",- tr_solver="lsmr",- verbose=2 * verbose,- max_nfev=max_nfev,- args=(p2ds, n_cam_params, extra),- )- best_params = opt.x-- for i, cam in enumerate(self.cameras):- a = i * n_cam_params- b = (i + 1) * n_cam_params- cam.set_params(best_params[a:b])-- error = self.average_error(p2ds)- return error-- @jit(parallel=True, forceobj=True)- def _error_fun_bundle(self, params, p2ds, n_cam_params, extra):- """Error function for bundle adjustment"""- good = ~np.isnan(p2ds)- n_cams = len(self.cameras)-- for i in range(n_cams):- cam = self.cameras[i]- a = i * n_cam_params- b = (i + 1) * n_cam_params- cam.set_params(params[a:b])-- n_cams = len(self.cameras)- sub = n_cam_params * n_cams- n3d = p2ds.shape[1] * 3- p3ds_test = params[sub: sub + n3d].reshape(-1, 3)- errors = self.reprojection_error(p3ds_test, p2ds)- errors_reproj = errors[good]-- if extra is not None:- ids = extra["ids_map"]- objp = extra["objp"]- min_scale = np.min(objp[objp > 0])- n_boards = int(np.max(ids)) + 1- a = sub + n3d- rvecs = params[a: a + n_boards * 3].reshape(-1, 3)- tvecs = params[a + n_boards * 3: a + n_boards * 6].reshape(-1, 3)- expected = transform_points(objp, rvecs[ids], tvecs[ids])- errors_obj = 2 * (p3ds_test - expected).ravel() / min_scale- else:- errors_obj = np.array([])-- return np.hstack([errors_reproj, errors_obj])-- def _jac_sparsity_bundle(self, p2ds, n_cam_params, extra):- """Given an CxNx2 array of 2D points,- where N is the number of points and C is the number of cameras,- compute the sparsity structure of the jacobian for bundle adjustment"""-- point_indices = np.zeros(p2ds.shape, dtype="int32")- cam_indices = np.zeros(p2ds.shape, dtype="int32")-- for i in range(p2ds.shape[1]):- point_indices[:, i] = i-- for j in range(p2ds.shape[0]):- cam_indices[j] = j-- good = ~np.isnan(p2ds)-- if extra is not None:- ids = extra["ids_map"]- n_boards = int(np.max(ids)) + 1- total_board_params = n_boards * (3 + 3) # rvecs + tvecs- else:- n_boards = 0- total_board_params = 0-- n_cams = p2ds.shape[0]- n_points = p2ds.shape[1]- total_params_reproj = n_cams * n_cam_params + n_points * 3- n_params = total_params_reproj + total_board_params-- n_good_values = np.sum(good)- if extra is not None:- n_errors = n_good_values + n_points * 3- else:- n_errors = n_good_values-- A_sparse = dok_matrix((n_errors, n_params), dtype="int16")-- cam_indices_good = cam_indices[good]- point_indices_good = point_indices[good]-- # -- reprojection error --- ix = np.arange(n_good_values)-- ## update camera params based on point error- for i in range(n_cam_params):- A_sparse[ix, cam_indices_good * n_cam_params + i] = 1-- ## update point position based on point error- for i in range(3):- A_sparse[ix, n_cams * n_cam_params + point_indices_good * 3 + i] = 1-- # -- match for the object points--- if extra is not None:- point_ix = np.arange(n_points)-- ## update all the camera parameters- # A_sparse[n_good_values:n_good_values+n_points*3,- # 0:n_cams*n_cam_params] = 1-- ## update board rotation and translation based on error from expected- for i in range(3):- for j in range(3):- A_sparse[- n_good_values + point_ix * 3 + i,- total_params_reproj + ids * 3 + j,- ] = 1- A_sparse[- n_good_values + point_ix * 3 + i,- total_params_reproj + n_boards * 3 + ids * 3 + j,- ] = 1-- ## update point position based on error from expected- for i in range(3):- A_sparse[- n_good_values + point_ix * 3 + i,- n_cams * n_cam_params + point_ix * 3 + i,- ] = 1-- return A_sparse-- def _initialize_params_bundle(self, p2ds, extra):- """Given an CxNx2 array of 2D points,- where N is the number of points and C is the number of cameras,- initializes the parameters for bundle adjustment"""-- cam_params = np.hstack([cam.get_params() for cam in self.cameras])- n_cam_params = len(cam_params) // len(self.cameras)-- total_cam_params = len(cam_params)-- n_cams, n_points, _ = p2ds.shape- assert n_cams == len(self.cameras), (- "number of cameras in CameraGroup does not " "match number of cameras in 2D points given"- )-- p3ds = self.triangulate(p2ds)-- if extra is not None:- ids = extra["ids_map"]- n_boards = int(np.max(ids[~np.isnan(ids)])) + 1- total_board_params = n_boards * (3 + 3) # rvecs + tvecs-- # initialize to 0- rvecs = np.zeros((n_boards, 3), dtype="float64")- tvecs = np.zeros((n_boards, 3), dtype="float64")-- if "rvecs" in extra and "tvecs" in extra:- rvecs_all = extra["rvecs"]- tvecs_all = extra["tvecs"]- for board_num in range(n_boards):- point_id = np.where(ids == board_num)[0][0]- cam_ids_possible = np.where(~np.isnan(p2ds[:, point_id, 0]))[0]- cam_id = np.random.choice(cam_ids_possible)- M_cam = self.cameras[cam_id].get_extrinsics_mat()- M_board_cam = make_M(rvecs_all[cam_id, point_id], tvecs_all[cam_id, point_id])- M_board = np.matmul(inverse(M_cam), M_board_cam)- rvec, tvec = get_rtvec(M_board)- rvecs[board_num] = rvec- tvecs[board_num] = tvec-- else:- total_board_params = 0-- x0 = np.zeros(total_cam_params + p3ds.size + total_board_params)- x0[:total_cam_params] = cam_params- x0[total_cam_params: total_cam_params + p3ds.size] = p3ds.ravel()-- if extra is not None:- start_board = total_cam_params + p3ds.size- x0[start_board: start_board + n_boards * 3] = rvecs.ravel()- x0[start_board + n_boards * 3: start_board + n_boards * 6] = tvecs.ravel()-- return x0, n_cam_params-- def optim_points(- self,- points,- p3ds,- constraints=[],- constraints_weak=[],- scale_smooth=4,- scale_length=2,- scale_length_weak=0.5,- reproj_error_threshold=15,- reproj_loss="soft_l1",- n_deriv_smooth=1,- scores=None,- verbose=False,- ):- """- Take in an array of 2D points of shape CxNxJx2,- an array of 3D points of shape NxJx3,- and an array of constraints of shape Kx2, where- C: number of camera- N: number of frames- J: number of joints- K: number of constraints-- This function creates an optimized array of 3D points of shape NxJx3.-- Example constraints:- constraints = [[0, 1], [1, 2], [2, 3]]- (meaning that lengths of segments 0->1, 1->2, 2->3 are all constant)-- """- assert points.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), points.shape- )-- n_cams, n_frames, n_joints, _ = points.shape- constraints = np.array(constraints)- constraints_weak = np.array(constraints_weak)-- p3ds_intp = np.apply_along_axis(interpolate_data, 0, p3ds)-- p3ds_med = np.apply_along_axis(medfilt_data, 0, p3ds_intp, size=7)-- default_smooth = 1.0 / np.mean(np.abs(np.diff(p3ds_med, axis=0)))- scale_smooth_full = scale_smooth * default_smooth-- t1 = time.time()-- x0 = self._initialize_params_triangulation(p3ds_intp, constraints, constraints_weak)-- x0[~np.isfinite(x0)] = 0-- jac = self._jac_sparsity_triangulation(points, constraints, constraints_weak, n_deriv_smooth)-- opt2 = optimize.least_squares(- self._error_fun_triangulation,- x0=x0,- jac_sparsity=jac,- loss="linear",- ftol=1e-3,- verbose=2 * verbose,- args=(- points,- constraints,- constraints_weak,- scores,- scale_smooth_full,- scale_length,- scale_length_weak,- reproj_error_threshold,- reproj_loss,- n_deriv_smooth,- ),- )-- p3ds_new2 = opt2.x[: p3ds.size].reshape(p3ds.shape)-- t2 = time.time()-- if verbose:- print("optimization took {:.2f} seconds".format(t2 - t1))-- return p3ds_new2-- def optim_points_possible(- self,- points,- p3ds,- constraints=[],- constraints_weak=[],- scale_smooth=4,- scale_length=2,- scale_length_weak=0.5,- reproj_error_threshold=15,- reproj_loss="soft_l1",- n_deriv_smooth=1,- scores=None,- verbose=False,- ):- """- Take in an array of 2D points of shape CxNxJxPx2,- an array of 3D points of shape NxJx3,- and an array of constraints of shape Kx2, where- C: number of camera- N: number of frames- J: number of joints- P: number of possible options per point- K: number of constraints-- This function creates an optimized array of 3D points of shape NxJx3.-- Example constraints:- constraints = [[0, 1], [1, 2], [2, 3]]- (meaning that lengths of segments 0->1, 1->2, 2->3 are all constant)-- """- assert points.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), points.shape- )-- n_cams, n_frames, n_joints, n_possible, _ = points.shape- constraints = np.array(constraints)- constraints_weak = np.array(constraints_weak)-- p3ds_intp = np.apply_along_axis(interpolate_data, 0, p3ds)-- p3ds_med = np.apply_along_axis(medfilt_data, 0, p3ds_intp, size=7)-- default_smooth = 1.0 / np.mean(np.abs(np.diff(p3ds_med, axis=0)))- scale_smooth_full = scale_smooth * default_smooth-- t1 = time.time()-- x0 = self._initialize_params_triangulation_possible(- p3ds_intp,- points,- constraints=constraints,- constraints_weak=constraints_weak,- )-- print("getting jacobian...")- jac = self._jac_sparsity_triangulation_possible(- points,- constraints=constraints,- constraints_weak=constraints_weak,- n_deriv_smooth=n_deriv_smooth,- )-- beta = 5-- print("starting optimization...")- opt2 = optimize.least_squares(- self._error_fun_triangulation_possible,- x0=x0,- jac_sparsity=jac,- loss="linear",- ftol=1e-3,- verbose=2 * verbose,- args=(- points,- beta,- constraints,- constraints_weak,- scores,- scale_smooth_full,- scale_length,- scale_length_weak,- reproj_error_threshold,- reproj_loss,- n_deriv_smooth,- ),- )- params = opt2.x-- p3ds_new2 = params[: p3ds.size].reshape(p3ds.shape)-- bad = np.isnan(points[:, :, :, :, 0])- all_bad = np.all(bad, axis=3)-- n_params_norm = p3ds.size + len(constraints) + len(constraints_weak)-- alphas = np.zeros((n_cams, n_frames, n_joints, n_possible), dtype="float64")- alphas[~bad] = params[n_params_norm:]-- alphas_exp = np.exp(beta * alphas)- alphas_exp[bad] = 0- alphas_sum = np.sum(alphas_exp, axis=3)- alphas_sum[all_bad] = 1- alphas_norm = alphas_exp / alphas_sum[:, :, :, None]- alphas_norm[bad] = np.nan-- t2 = time.time()-- if verbose:- print("optimization took {:.2f} seconds".format(t2 - t1))-- return p3ds_new2, alphas_norm-- def triangulate_optim(self, points, init_ransac=False, init_progress=False, **kwargs):- """- Take in an array of 2D points of shape CxNxJx2, and an array of constraints of shape Kx2, where- C: number of camera- N: number of frames- J: number of joints- K: number of constraints-- This function creates an optimized array of 3D points of shape NxJx3.-- Example constraints:- constraints = [[0, 1], [1, 2], [2, 3]]- (meaning that lengths of segments 0->1, 1->2, 2->3 are all constant)-- """-- assert points.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), points.shape- )-- n_cams, n_frames, n_joints, _ = points.shape- # constraints = np.array(constraints)- # constraints_weak = np.array(constraints_weak)-- points_shaped = points.reshape(n_cams, n_frames * n_joints, 2)- if init_ransac:- p3ds, picked, p2ds, errors = self.triangulate_ransac(points_shaped, progress=init_progress)- points = p2ds.reshape(points.shape)- else:- p3ds = self.triangulate(points_shaped, progress=init_progress)- p3ds = p3ds.reshape((n_frames, n_joints, 3))-- c = np.isfinite(p3ds[:, :, 0])- if np.sum(c) < 20:- print("warning: not enough 3D points to calculate_center_of_mass optimization")- return p3ds-- return self.optim_points(points, p3ds, **kwargs)-- @jit(forceobj=True, parallel=True)- def _error_fun_triangulation(- self,- params,- p2ds,- constraints=[],- constraints_weak=[],- scores=None,- scale_smooth=10000,- scale_length=1,- scale_length_weak=0.2,- reproj_error_threshold=100,- reproj_loss="soft_l1",- n_deriv_smooth=1,- ):- n_cams, n_frames, n_joints, _ = p2ds.shape-- n_3d = n_frames * n_joints * 3- n_constraints = len(constraints)- n_constraints_weak = len(constraints_weak)-- # load params- p3ds = params[:n_3d].reshape((n_frames, n_joints, 3))- joint_lengths = np.array(params[n_3d: n_3d + n_constraints])- joint_lengths_weak = np.array(params[n_3d + n_constraints:])-- # reprojection errors- p3ds_flat = p3ds.reshape(-1, 3)- p2ds_flat = p2ds.reshape((n_cams, -1, 2))- errors = self.reprojection_error(p3ds_flat, p2ds_flat)- if scores is not None:- scores_flat = scores.reshape((n_cams, -1))- errors = errors * scores_flat[:, :, None]- errors_reproj = errors[~np.isnan(p2ds_flat)]-- rp = reproj_error_threshold- errors_reproj = np.abs(errors_reproj)- if reproj_loss == "huber":- bad = errors_reproj > rp- errors_reproj[bad] = rp * (2 * np.sqrt(errors_reproj[bad] / rp) - 1)- elif reproj_loss == "linear":- pass- elif reproj_loss == "soft_l1":- errors_reproj = rp * 2 * (np.sqrt(1 + errors_reproj / rp) - 1)-- # temporal constraint- errors_smooth = np.diff(p3ds, n=n_deriv_smooth, axis=0).ravel() * scale_smooth-- # joint length constraint- errors_lengths = np.empty((n_constraints, n_frames), dtype="float64")- for cix, (a, b) in enumerate(constraints):- lengths = np.linalg.norm(p3ds[:, a] - p3ds[:, b], axis=1)- expected = joint_lengths[cix]- errors_lengths[cix] = 100 * (lengths - expected) / expected- errors_lengths = errors_lengths.ravel() * scale_length-- errors_lengths_weak = np.empty((n_constraints_weak, n_frames), dtype="float64")- for cix, (a, b) in enumerate(constraints_weak):- lengths = np.linalg.norm(p3ds[:, a] - p3ds[:, b], axis=1)- expected = joint_lengths_weak[cix]- errors_lengths_weak[cix] = 100 * (lengths - expected) / expected- errors_lengths_weak = errors_lengths_weak.ravel() * scale_length_weak-- return np.hstack([errors_reproj, errors_smooth, errors_lengths, errors_lengths_weak])-- def _error_fun_triangulation_possible(self, params, p2ds, beta=2, constraints=[], constraints_weak=[], *args):- # extract alphas from end of params- # soft argmax for picking the appropriate points from p2ds- # pass the points to error_fun_triangulate_possible for residuals- # add errors to keep the alphas in check- # return all the errors-- n_cams, n_frames, n_joints, n_possible, _ = p2ds.shape-- n_3d = n_frames * n_joints * 3- n_constraints = len(constraints)- n_constraints_weak = len(constraints_weak)- n_params_norm = n_3d + n_constraints + n_constraints_weak-- # load params- bad = np.isnan(p2ds[:, :, :, :, 0])- all_bad = np.all(bad, axis=3)-- alphas = np.zeros((n_cams, n_frames, n_joints, n_possible), dtype="float64")- alphas[~bad] = params[n_params_norm:]- params_rest = np.array(params[:n_params_norm])-- # get normalized alphas- alphas_exp = np.exp(beta * alphas)- alphas_exp[bad] = 0- alphas_sum = np.sum(alphas_exp, axis=3)- alphas_sum[all_bad] = 1- alphas_norm = alphas_exp / alphas_sum[:, :, :, None]-- # extract the 2D points using soft argmax- p2ds_test = np.copy(p2ds)- p2ds_test[bad] = 0- p2ds_adj = np.sum(alphas_norm[:, :, :, :, None] * p2ds_test, axis=3)- p2ds_adj[all_bad] = np.nan-- errors = self._error_fun_triangulation(params_rest, p2ds_adj, constraints, constraints_weak, *args)-- alphas_test = alphas_norm[~all_bad]- errors_alphas = (1 - np.std(alphas_test, axis=1)) * 10-- return np.hstack([errors, errors_alphas])-- def _initialize_params_triangulation(self, p3ds, constraints=[], constraints_weak=[]):- joint_lengths = np.empty(len(constraints), dtype="float64")- joint_lengths_weak = np.empty(len(constraints_weak), dtype="float64")-- for cix, (a, b) in enumerate(constraints):- lengths = np.linalg.norm(p3ds[:, a] - p3ds[:, b], axis=1)- joint_lengths[cix] = np.median(lengths)-- for cix, (a, b) in enumerate(constraints_weak):- lengths = np.linalg.norm(p3ds[:, a] - p3ds[:, b], axis=1)- joint_lengths_weak[cix] = np.median(lengths)-- all_lengths = np.hstack([joint_lengths, joint_lengths_weak])- med = np.median(all_lengths)- if med == 0:- med = 1e-3-- mad = np.median(np.abs(all_lengths - med))-- joint_lengths[joint_lengths == 0] = med- joint_lengths_weak[joint_lengths_weak == 0] = med- joint_lengths[joint_lengths > med + mad * 5] = med- joint_lengths_weak[joint_lengths_weak > med + mad * 5] = med-- return np.hstack([p3ds.ravel(), joint_lengths, joint_lengths_weak])-- def _initialize_params_triangulation_possible(self, p3ds, p2ds, **kwargs):- # initialize params using above function- # initialize alphas to 1 for first one and 0 for other possible-- n_cams, n_frames, n_joints, n_possible, _ = p2ds.shape- good = ~np.isnan(p2ds[:, :, :, :, 0])-- alphas = np.zeros((n_cams, n_frames, n_joints, n_possible), dtype="float64")- alphas[:, :, :, 0] = 0-- params = self._initialize_params_triangulation(p3ds, **kwargs)- params_full = np.hstack([params, alphas[good]])-- return params_full-- def _jac_sparsity_triangulation(self, p2ds, constraints=[], constraints_weak=[], n_deriv_smooth=1):- n_cams, n_frames, n_joints, _ = p2ds.shape- n_constraints = len(constraints)- n_constraints_weak = len(constraints_weak)-- p2ds_flat = p2ds.reshape((n_cams, -1, 2))-- point_indices = np.zeros(p2ds_flat.shape, dtype="int32")- for i in range(p2ds_flat.shape[1]):- point_indices[:, i] = i-- point_indices_3d = np.arange(n_frames * n_joints).reshape((n_frames, n_joints))-- good = ~np.isnan(p2ds_flat)- n_errors_reproj = np.sum(good)- n_errors_smooth = (n_frames - n_deriv_smooth) * n_joints * 3- n_errors_lengths = n_constraints * n_frames- n_errors_lengths_weak = n_constraints_weak * n_frames-- n_errors = n_errors_reproj + n_errors_smooth + n_errors_lengths + n_errors_lengths_weak-- n_3d = n_frames * n_joints * 3- n_params = n_3d + n_constraints + n_constraints_weak-- point_indices_good = point_indices[good]-- A_sparse = dok_matrix((n_errors, n_params), dtype="int16")-- # constraints for reprojection errors- ix_reproj = np.arange(n_errors_reproj)- for k in range(3):- A_sparse[ix_reproj, point_indices_good * 3 + k] = 1-- # sparse constraints for smoothness in time- frames = np.arange(n_frames - n_deriv_smooth)- for j in range(n_joints):- for n in range(n_deriv_smooth + 1):- pa = point_indices_3d[frames, j]- pb = point_indices_3d[frames + n, j]- for k in range(3):- A_sparse[n_errors_reproj + pa * 3 + k, pb * 3 + k] = 1-- ## -- strong constraints --- # joint lengths should change with joint lengths errors- start = n_errors_reproj + n_errors_smooth- frames = np.arange(n_frames)- for cix, (a, b) in enumerate(constraints):- A_sparse[start + cix * n_frames + frames, n_3d + cix] = 1-- # points should change accordingly to match joint lengths too- frames = np.arange(n_frames)- for cix, (a, b) in enumerate(constraints):- pa = point_indices_3d[frames, a]- pb = point_indices_3d[frames, b]- for k in range(3):- A_sparse[start + cix * n_frames + frames, pa * 3 + k] = 1- A_sparse[start + cix * n_frames + frames, pb * 3 + k] = 1-- ## -- weak constraints --- # joint lengths should change with joint lengths errors- start = n_errors_reproj + n_errors_smooth + n_errors_lengths- frames = np.arange(n_frames)- for cix, (a, b) in enumerate(constraints_weak):- A_sparse[start + cix * n_frames + frames, n_3d + n_constraints + cix] = 1-- # points should change accordingly to match joint lengths too- frames = np.arange(n_frames)- for cix, (a, b) in enumerate(constraints_weak):- pa = point_indices_3d[frames, a]- pb = point_indices_3d[frames, b]- for k in range(3):- A_sparse[start + cix * n_frames + frames, pa * 3 + k] = 1- A_sparse[start + cix * n_frames + frames, pb * 3 + k] = 1-- return A_sparse-- def _jac_sparsity_triangulation_possible(self, p2ds_full, **kwargs):- # initialize sparse jacobian using above function- # extend to include alphas from parameters- ## TODO: this initialization is really slow for some reason-- n_cams, n_frames, n_joints, n_possible, _ = p2ds_full.shape- good_full = ~np.isnan(p2ds_full[:, :, :, :, 0])- any_good = np.any(good_full, axis=3)-- n_alphas = np.sum(good_full)- n_errors_alphas = np.sum(any_good)-- p2ds = p2ds_full[:, :, :, 0]- A_sparse = self._jac_sparsity_triangulation(p2ds, **kwargs)-- n_errors, n_params = A_sparse.shape-- B_sparse = dok_matrix((n_errors + n_errors_alphas, n_params + n_alphas), dtype="int16")- for r, c in zip(*A_sparse.nonzero()):- B_sparse[r, c] = A_sparse[r, c]-- point_indices_2d = np.arange(n_cams * n_frames * n_joints).reshape(n_cams, n_frames, n_joints)- point_indices_2d_rep = np.repeat(point_indices_2d[:, :, :, None], 2, axis=3)- point_indices_2d_good = point_indices_2d_rep[~np.isnan(p2ds)]- point_indices_good = point_indices_2d[any_good]-- alpha_indices = np.zeros((n_cams, n_frames, n_joints, n_possible), dtype="int64")- for pnum in range(n_possible):- alpha_indices[:, :, :, pnum] = point_indices_2d-- alpha_indices_good = alpha_indices[good_full]-- # alphas should change according to the reprojection error for each corresponding point- point_indices_2d_good_find = defaultdict(list)- for ix, p in enumerate(point_indices_2d_good):- point_indices_2d_good_find[p].append(ix)-- for ix, alpha_index in enumerate(alpha_indices_good):- B_sparse[point_indices_2d_good_find[alpha_index], n_params + ix] = 1-- # alphas should change according to the alpha errors- point_indices_good_find = dict()- for ix, p in enumerate(point_indices_good):- point_indices_good_find[p] = ix-- for ix, alpha_index in enumerate(alpha_indices_good):- if alpha_index in point_indices_good_find:- err_ix = n_errors + point_indices_good_find[alpha_index]- B_sparse[err_ix, n_params + ix] = 1-- return B_sparse-- def copy(self):- cameras = [cam.copy() for cam in self.cameras]- metadata = copy(self.metadata)- return AniposeCameraGroup(cameras, metadata)-- def set_rotations(self, rvecs):- for cam, rvec in zip(self.cameras, rvecs):- cam.set_rotation(rvec)-- def set_translations(self, tvecs):- for cam, tvec in zip(self.cameras, tvecs):- cam.set_translation(tvec)-- def set_world_positions(self, positions):- for cam, position, in zip(self.cameras, positions):- cam.set_world_position(position)-- def set_world_orientations(self, orientations):- for cam, orientation in zip(self.cameras, orientations):- cam.set_world_orientation(orientation)-- def get_world_positions(self):- return np.stack([cam.get_world_position() for cam in self.cameras])-- def get_world_orientations(self):- return np.stack([cam.get_world_orientation() for cam in self.cameras])-- def get_rotations(self):- rvecs = []- for cam in self.cameras:- rvec = cam.get_rotation()- rvecs.append(rvec)- return np.array(rvecs)-- def get_translations(self):- tvecs = []- for cam in self.cameras:- tvec = cam.get_translation()- tvecs.append(tvec)- return np.array(tvecs)-- def get_names(self):- return [cam.get_name() for cam in self.cameras]-- def set_names(self, names):- for cam, name in zip(self.cameras, names):- cam.set_name(name)-- def average_error(self, p2ds, median=False):- p3ds = self.triangulate(p2ds)- errors = self.reprojection_error(p3ds, p2ds, mean=True)- if median:- return np.median(errors)- else:- return np.mean(errors)-- def calibrate_rows(- self,- all_rows: list[list[dict]],- board,- init_intrinsics: bool = True,- init_extrinsics: bool = True,- verbose: bool = True,- ) -> tuple[float, list, list]:- """- Calibrate cameras from charuco board observations.-- Args:- all_rows: List of observation rows per camera- board: Charuco board definition- init_intrinsics: Whether to initialize camera intrinsics- init_extrinsics: Whether to initialize camera extrinsics- verbose: Enable verbose logging-- Returns:- Tuple of (error, merged_rows, charuco_frame_numbers)- """- n_cameras = len(self.cameras)- n_rows_list = len(all_rows)-- logger.info("=" * 80)- logger.info("STARTING CAMERA CALIBRATION")- logger.info("=" * 80)-- assert n_rows_list == n_cameras, \- f"Number of camera detections ({n_rows_list}) does not match number of cameras ({n_cameras})"-- # Log observation statistics per camera- logger.info(f"Calibrating {n_cameras} cameras")- for cam_idx, (rows, camera) in enumerate(zip(all_rows, self.cameras)):- logger.info(f"Camera {cam_idx} ({camera.get_name()}): {len(rows)} frames with detections")-- size = camera.get_size()- assert size is not None, \- f"Camera with name {camera.get_name()} has no specified frame size"- logger.debug(f" Camera size: {size}")-- # Initialize intrinsics- if init_intrinsics:- logger.info("Initializing camera intrinsics...")- for cam_idx, (rows, camera) in enumerate(zip(all_rows, self.cameras)):- logger.debug(f" Camera {cam_idx}: Extracting calibration points")- objp, imgp = board.get_all_calibration_points(rows)-- logger.debug(f" Found {len(objp)} object point sets and {len(imgp)} image point sets")-- mixed = [(o, i) for (o, i) in zip(objp, imgp) if len(o) >= 7]-- if len(mixed) == 0:- logger.error(f" Camera {cam_idx}: No valid calibration points (need at least 7 points)")- raise ValueError(f"No valid calibration points for camera {cam_idx}")-- logger.info(f" Camera {cam_idx}: Using {len(mixed)} frames for intrinsics (min 7 points each)")-- objp, imgp = zip(*mixed)-- try:- matrix = cv2.initCameraMatrix2D(objp, imgp, tuple(camera.get_size()))- camera.set_camera_matrix(matrix)- logger.debug(f" Camera {cam_idx}: Initialized camera matrix:\n{matrix}")- except Exception as e:- logger.error(f" Camera {cam_idx}: Failed to initialize camera matrix - {e}")- raise-- logger.info("✓ Camera intrinsics initialized successfully")-- # Estimate poses- logger.info("Estimating board poses for all cameras...")- for i, (row, cam) in enumerate(zip(all_rows, self.cameras)):- logger.debug(f" Camera {i}: Estimating poses for {len(row)} frames")- all_rows[i] = board.estimate_pose_rows(cam, row)- logger.info("✓ Board poses estimated")-- # Extract frame numbers- charuco_frames = [f["framenum"][1] for f in all_rows[0]]- logger.debug(f"Frame numbers from camera 0: {charuco_frames[:10]}..." if len(- charuco_frames) > 10 else f"Frame numbers: {charuco_frames}")-- # Merge observations across cameras- logger.info("Merging observations across cameras...")- merged = merge_rows(all_rows)- logger.info(f"✓ Merged {len(merged)} multi-camera observations")-- # Extract points for calibration- logger.info("Extracting calibration points (minimum 2 cameras per point)...")- imgp, extra = extract_points(merged, board, min_cameras=2)- logger.info(f"✓ Extracted points: shape={imgp.shape}")- logger.debug(f" Extra data keys: {extra.keys() if extra else 'None'}")-- # Initialize extrinsics- if init_extrinsics:- logger.info("Initializing camera extrinsics...")-- logger.debug("Extracting rotation/translation vectors from observations")- rtvecs = extract_rtvecs(merged)- logger.info(f" Extracted rtvecs: shape={rtvecs.shape}")-- # Log connections between cameras- if verbose:- logger.info("Camera pair connections (shared observations):")- connections = get_connections(rtvecs, self.get_names())-- # Sort by camera pair for readable output- for (cam_a, cam_b), count in sorted(connections.items()):- if cam_a < cam_b: # Only show each pair once- logger.info(f" {cam_a} <-> {cam_b}: {count} frames")-- logger.debug("Computing initial extrinsics from observations")- try:- rvecs, tvecs = get_initial_extrinsics(rtvecs, cam_names=self.get_names())- self.set_rotations(rvecs)- self.set_translations(tvecs)- logger.info("✓ Initial extrinsics computed successfully")- except Exception as e:- logger.error(f"Failed to compute initial extrinsics: {e}")- logger.error("This usually means insufficient shared observations between cameras")- raise-- # Bundle adjustment- logger.info("Starting iterative bundle adjustment...")- logger.info(f" Input points shape: {imgp.shape}")- logger.info(f" Error threshold: 1.0")-- try:- error = self.bundle_adjust_iter(imgp, extra, verbose=verbose, error_threshold=1)- logger.info(f"✓ Bundle adjustment completed successfully")- logger.info(f" Final reprojection error: {error:.4f}")- except Exception as e:- logger.error(f"Bundle adjustment failed: {e}")- raise-- logger.info("=" * 80)- logger.info(f"CALIBRATION COMPLETE - Final error: {error:.4f}")- logger.info("=" * 80)-- return error, merged, charuco_frames-- def get_rows_videos(self, videos: List[List[str]], board: "AniposeCharucoBoard", verbose: bool = True):- num_corners = board.total_size- self._get_charuco_2d_data(videos=videos, board=board)-- if self.charuco_2d_data is None:- raise ValueError(- "Charuco 2D data has not been initialized. Call _get_charuco_2d_data() first, or check for errors in the video processing.")-- all_rows = []-- num_cameras, num_frames, _, _ = self.charuco_2d_data.shape- for camera_number in range(num_cameras):- camera_rows = []- for frame in range(num_frames):- filled = self.charuco_2d_data[camera_number, frame, :, :]- filled = filled.astype(np.float32)- filled = np.reshape(filled, (num_corners, 1, 2)) # Add empty column anipose expects- mask = (~np.isnan(filled[:, :, 0])) & (~np.isnan(filled[:, :, 1]))- non_empty_ids = np.where(mask)[0]- corners = filled[non_empty_ids, :, :]- non_empty_ids = non_empty_ids.reshape(-1, 1) # Add empty column anipose expects- if corners.shape[0] != 0:- row = {- "framenum": (0, frame),- "corners": corners,- "ids": non_empty_ids,- "filled": filled,- }- camera_rows.append(row)- all_rows.append(camera_rows)- if verbose:- print(f"Charuco detection results:")- for i, rows in enumerate(all_rows):- print(f"\tCamera {i} has {len(rows)} frames with detected corners.")-- return all_rows-- def _get_charuco_2d_data(self, videos: List[List[str]], board: "AniposeCharucoBoard"):- """- Processes a list of a list of videos to extract Charuco 2D data.-- Should be called once during the initial calibration, and then referenced with self.charuco_2d_data- """- # video_paths = [Path(video[0]) for video in videos]- # charuco_2d_data = process_list_of_videos(- # model_info=CharucoModelInfo(),- # tracking_params=CharucoTrackingParams(- # charuco_squares_x_in=board.squaresX,- # charuco_squares_y_in=board.squaresY,- # charuco_dict_id=ARUCO_DICTS[(board.marker_bits, board.dict_size)]- # ),- # video_paths=video_paths,- # num_processes=min(len(videos), multiprocessing.cpu_count() - 1),- # )- #- # self.charuco_2d_data = charuco_2d_data- pass-- def set_camera_sizes_videos(self, videos):- for cix, (cam, cam_videos) in enumerate(zip(self.cameras, videos)):- rows_cam = []- for vnum, vidname in enumerate(cam_videos):- params = get_video_params(vidname)- size = (params["width"], params["height"])- cam.set_size(size)-- def calibrate_videos(- self,- videos,- board: "AniposeCharucoBoard",- init_intrinsics=True,- init_extrinsics=True,- verbose=True,- **kwargs,- ):- """Takes as input a list of list of video filenames, one list of each camera.- Also takes a board which specifies what should be detected in the videos"""-- all_rows = self.get_rows_videos(videos, board, verbose=verbose)- if init_extrinsics:- self.set_camera_sizes_videos(videos)-- error, merged, charuco_frames = self.calibrate_rows(- all_rows,- board,- init_intrinsics=init_intrinsics,- init_extrinsics=init_extrinsics,- verbose=verbose,- )- return error, merged, charuco_frames-- def get_dicts(self):- out = []- for cam in self.cameras:- out.append(cam.get_dict())- return out-- @staticmethod- def from_dicts(cameras_dicts):- cameras = []- for d in cameras_dicts:- cam = AniposeCamera.from_dict(d)- cameras.append(cam)- return AniposeCameraGroup(cameras)-- @staticmethod- def from_names(names, fisheye=False):- cameras = []- for name in names:- cam = AniposeCamera(name=name)- cameras.append(cam)- return AniposeCameraGroup(cameras)-- def load_dicts(self, arr):- for cam, d in zip(self.cameras, arr):- cam.load_dict(d)-- def dump(self, fname):- dicts = self.get_dicts()- names = [camera_dict['name'] for camera_dict in dicts]- master_dict = dict(zip(names, dicts))- master_dict["metadata"] = self.metadata- with open(fname, "w") as f:- toml.dump(master_dict, f)-- @staticmethod- def load(fname: str):- if not Path(fname).is_file():- raise FileNotFoundError(f"File {fname} not found.")- master_dict = toml.load(fname)- keys = sorted(master_dict.keys())- items = [master_dict[k] for k in keys if k != "metadata"]- cgroup = AniposeCameraGroup.from_dicts(items)- if "metadata" in master_dict:- cgroup.metadata = master_dict["metadata"]- return cgroup-- def resize_cameras(self, scale):- for cam in self.cameras:- cam.resize_camera(scale)-- @jit(parallel=True, forceobj=True)- def calculate_mean_reprojection_error(self, errors):- errors_norm = np.linalg.norm(errors, axis=2)- good = ~np.isnan(errors_norm)- errors_norm[~good] = 0- denom = np.sum(good, axis=0).astype("float64")- denom[denom < 1.5] = np.nan- errors = np.sum(errors_norm, axis=0) / denom- return errors----class AniposeCharucoBoard(CharucoBoard):- def __init__(- self,- squaresX: int = 5,- squaresY: int = 7,- square_length: float = 1.0,- marker_length: float = 0.8,- marker_bits=4,- dict_size=250,- ):- super().__init__(- squaresX,- squaresY,- square_length,- marker_length,- marker_bits,- dict_size,- )- self.squaresX = squaresX- self.squaresY = squaresY- self.square_length = square_length- self.marker_length = marker_length- self.marker_bits = marker_bits- self.dict_size = dict_size-- dkey = (marker_bits, dict_size)- self.dictionary = cv2.aruco.getPredefinedDictionary(ARUCO_DICTS[dkey])-- self.board = cv2.aruco.CharucoBoard(- size=[squaresX, squaresY],- squareLength=square_length,- markerLength=marker_length,- dictionary=self.dictionary,- )-- total_size = (squaresX - 1) * (squaresY - 1)-- objp = np.zeros((total_size, 3), np.float64)- objp[:, :2] = np.mgrid[0: (squaresX - 1), 0: (squaresY - 1)].T.reshape(-1, 2)- objp *= square_length- self.objPoints = objp-- self.empty_detection = np.zeros((total_size, 1, 2)) * np.nan- self.total_size = total_size-- def detect_markers(self, image, camera=None, refine=True):- if len(image.shape) == 3:- gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)- else:- gray = image-- params = cv2.aruco.DetectorParameters()- params.cornerRefinementMethod = cv2.aruco.CORNER_REFINE_CONTOUR- params.adaptiveThreshWinSizeMin = 100- params.adaptiveThreshWinSizeMax = 700- params.adaptiveThreshWinSizeStep = 50- params.adaptiveThreshConstant = 0-- try:- corners, ids, rejectedImgPoints = cv2.aruco.detectMarkers(gray, self.dictionary, parameters=params)- except Exception:- ids = None-- if ids is None:- return [], []-- if camera is None:- K = D = None- else:- K = camera.get_camera_matrix()- D = camera.get_distortions()-- if refine:- detectedCorners, detectedIds, rejectedCorners, recoveredIdxs = cv2.aruco.refineDetectedMarkers(- gray, self.board, corners, ids, rejectedImgPoints, K, D, parameters=params- )- else:- detectedCorners, detectedIds = corners, ids-- return detectedCorners, detectedIds-- def detect_image(self, image, camera=None):- if len(image.shape) == 3:- gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)- else:- gray = image-- corners, ids = self.detect_markers(image, camera, refine=True)- if len(corners) > 0:- ret, detectedCorners, detectedIds = cv2.aruco.interpolateCornersCharuco(corners, ids, gray, self.board)- if detectedIds is None:- detectedCorners = detectedIds = np.float64([])- else:- detectedCorners = detectedIds = np.float64([])-- return detectedCorners, detectedIds-- def estimate_pose_points(self, camera: AniposeCamera, corners: np.ndarray | None, ids: np.ndarray | None) -> tuple[- np.ndarray | None, np.ndarray | None]:- if corners is None or ids is None or len(corners) < 5:- return None, None-- n_corners = corners.size // 2- corners = np.reshape(corners, (n_corners, 1, 2))-- # Ensure corners are float32 for OpenCV- corners = corners.astype(np.float32)-- # Ensure ids are the correct dtype as well- ids = ids.astype(np.int32) if ids.dtype != np.int32 else ids-- K = camera.get_camera_matrix()- D = camera.get_distortions()-- ret, rvec, tvec = cv2.aruco.estimatePoseCharucoBoard(corners, ids, self.board, K, D, None, None)-- return rvec, tvecdiff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/point_triangulator.py b/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/point_triangulator.pydeleted file mode 100644index cc35410c..00000000--- a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_helpers/point_triangulator.py+++ /dev/null@@ -1,422 +0,0 @@-from dataclasses import dataclass, field-from pathlib import Path--import cv2-import numpy as np-from skellycam.core.types.type_overloads import CameraIdString--from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.camera_math_models import \- CameraDistortionCoefficients, \- CameraMatrix-from freemocap.pubsub.pubsub_topics import CameraNodeOutputMessage---def _triangulate_batch(- points2d: np.ndarray,- projection_matrices: np.ndarray,-) -> np.ndarray:- """- Vectorized triangulation using Direct Linear Transform (DLT) method.-- DLT constructs a homogeneous linear system AX=0 where each camera contributes 2 rows:-- For N cameras observing point X=[X,Y,Z,1]ᵀ:-- Camera 0: [x₀·P₃ - P₁] [X]- [y₀·P₃ - P₂] [Y]- Camera 1: [x₁·P₃ - P₁] × [Z] = 0- [y₁·P₃ - P₂] [1]- ⋮ ⋮- Camera N: [xₙ·P₃ - P₁]- [yₙ·P₃ - P₂]-- Matrix A is (2N × 4), where P₁, P₂, P₃ are rows of projection matrix P.-- Solution via SVD: A = UΣVᵀ, take last row of V (min singular value), normalize by w:- [X, Y, Z, w]ᵀ → (X/w, Y/w, Z/w)-- :param points2d: Shape (M, N, 2) - M points observed by N cameras (pixel coordinates)- :param projection_matrices: Shape (N, 3, 4) - full projection matrices P = K[R|t]- :param preallocated_arrays: Optional pre-allocated arrays (auto-resizes if needed)- :return: Shape (M, 3) - triangulated 3D positions in world coordinates- """- num_points = points2d.shape[0]- num_cameras = projection_matrices.shape[0]-- A_matrices = np.zeros((num_points, num_cameras * 2, 4), dtype=np.float64)- points3d_output = np.empty((num_points, 3), dtype=np.float64)-- # Zero out A_matrices in case we're reusing pre-allocated array- A_matrices.fill(0.0)-- # Build all A matrices at once- for cam_idx in range(num_cameras):- x = points2d[:, cam_idx, 0] # All points, this camera, x coord- y = points2d[:, cam_idx, 1] # All points, this camera, y coord- mat = projection_matrices[cam_idx]-- # Vectorized construction- A_matrices[:, cam_idx * 2] = x[:, None] * mat[2] - mat[0]- A_matrices[:, cam_idx * 2 + 1] = y[:, None] * mat[2] - mat[1]-- # Batch SVD on all matrices at once- _, _, vh = np.linalg.svd(A_matrices, full_matrices=False)-- # Extract last row of vh for each point- points3d_h = vh[:, -1, :] # Shape: (num_points, 4)-- # Normalize by w and write directly to output array- points3d_output[:] = points3d_h[:, :3] / points3d_h[:, 3:4]-- return points3d_output---@dataclass-class CameraCalibrationData:- """Camera calibration parameters for a single camera."""-- name: str- image_size: tuple[int, int] # (width, height)- matrix: CameraMatrix- distortion: CameraDistortionCoefficients- rotation_vector: np.ndarray # 3x1 Rodrigues rotation vector- translation: np.ndarray # 3x1 XYZ translation vector- world_position: np.ndarray = field(init=False)- world_orientation: np.ndarray = field(init=False)-- @classmethod- def from_dict(cls, camera_id: str, data: dict) -> "CameraCalibrationData":- """Create from dictionary (e.g., loaded from TOML)."""- if 'image_size' in data:- image_size_list = data["image_size"]- elif 'size' in data:- image_size_list = data["size"]- else:- raise KeyError("Camera calibration data must contain 'size' or 'image_size' key")-- if len(image_size_list) != 2:- raise ValueError(f"Expected size to have 2 elements, got {len(image_size_list)}")-- return cls(- name=camera_id,- image_size=(int(image_size_list[0]), int(image_size_list[1])),- matrix=CameraMatrix(matrix=np.asarray(data["matrix"])),- distortion=CameraDistortionCoefficients(coefficients=data["distortions"]),- rotation_vector=np.array(data["rotation"], dtype=np.float64),- translation=np.array(data["translation"], dtype=np.float64),- )-- def __post_init__(self) -> None:- """Validate shapes and compute world coordinates after initialization."""- if self.matrix.matrix.shape != (3, 3):- raise ValueError(f"Expected matrix shape (3, 3), got {self.matrix.matrix.shape}")- if self.distortion.coefficients.shape != (5,):- raise ValueError(f"Expected distortion shape (5,), got {self.distortion.coefficients.shape}")- if self.rotation_vector.shape != (3,):- raise ValueError(f"Expected rotation_vector shape (3,), got {self.rotation_vector.shape}")- if self.translation.shape != (3,):- raise ValueError(f"Expected translation shape (3,), got {self.translation.shape}")-- rotation_matrix = self.rotation_matrix- object.__setattr__(self, 'world_position', -rotation_matrix.T @ self.translation)- object.__setattr__(self, 'world_orientation', rotation_matrix.T)-- @property- def rotation_matrix(self) -> np.ndarray:- """Convert Rodrigues rotation vector to 3x3 rotation matrix."""- return cv2.Rodrigues(self.rotation_vector)[0]-- @property- def extrinsics_matrix(self) -> np.ndarray:- """Extrinsic matrix [R|t] of shape (3, 4)."""- extrinsics = np.zeros((3, 4), dtype=np.float64)- extrinsics[:, :3] = self.rotation_matrix- extrinsics[:, 3] = self.translation- return extrinsics-- @property- def projection_matrix(self) -> np.ndarray:- """Full projection matrix P = K[R|t] of shape (3, 4)."""- return self.matrix.matrix @ self.extrinsics_matrix-- def undistort_points(self, points: np.ndarray) -> np.ndarray:- """- Undistort 2D points and normalize to camera coordinates.-- :param points: Shape (N, 2) or (N, 1, 2) - distorted pixel coordinates- :return: Shape (N, 2) - undistorted normalized coordinates- """- original_shape = points.shape- points = points.reshape(-1, 1, 2)- undistorted = cv2.undistortPoints(- points,- self.matrix.matrix.astype(np.float64),- self.distortion.coefficients.astype(np.float64)- )- return undistorted.reshape(original_shape)-- def project_3d_to_2d(self, points3d: np.ndarray) -> np.ndarray:- """- Project 3D points to 2D image coordinates (with distortion).-- :param points3d: Shape (N, 3) - 3D world coordinates- :return: Shape (N, 2) - 2D pixel coordinates- """- points3d = points3d.reshape(-1, 1, 3)- projected, _ = cv2.projectPoints(- points3d,- self.rotation_vector,- self.translation,- self.matrix.matrix,- self.distortion.coefficients- )- return np.squeeze(projected, axis=1)---@dataclass-class PointTriangulator:- """- Fast triangulator for high-framerate multi-camera 3D reconstruction.-- Supports both array-based (fast) and dictionary-based (convenient) APIs.- """-- camera_calibrations: dict[str, CameraCalibrationData]- projection_matrices: np.ndarray = field(init=False)- camera_names: list[str] = field(init=False)- num_cameras: int = field(init=False)-- @classmethod- def from_toml(cls, toml_path: str | Path) -> "PointTriangulator":- """- Load camera calibrations from TOML file.-- :param toml_path: Path to calibration TOML file- :return: Initialized Triangulator- """- import toml-- calibration_data = toml.load(toml_path)- calibration_data.pop("metadata", None)-- camera_calibrations = {- camera_id: CameraCalibrationData.from_dict(camera_id, data)- for camera_id, data in calibration_data.items()- }-- return cls(camera_calibrations=camera_calibrations)-- def __post_init__(self) -> None:- """Validate and prepare projection matrices after initialization."""- if not self.camera_calibrations:- raise ValueError("camera_calibrations cannot be empty")-- self.num_cameras = len(self.camera_calibrations)- self.camera_names = list(self.camera_calibrations.keys())-- projection_matrices = np.array(- [cam.projection_matrix for cam in self.camera_calibrations.values()],- dtype=np.float64- )-- if projection_matrices.shape != (self.num_cameras, 3, 4):- raise ValueError(- f"Expected projection matrices shape ({self.num_cameras}, 3, 4), "- f"got {projection_matrices.shape}"- )-- object.__setattr__(- self,- 'projection_matrices',- np.ascontiguousarray(projection_matrices, dtype=np.float64)- )-- def triangulate_camera_node_outputs(- self,- camera_node_outputs: dict[CameraIdString, CameraNodeOutputMessage],- undistort_points: bool = True,- compute_reprojection_error: bool = False- ) -> tuple[np.ndarray, np.ndarray | None]:- """- Triangulate 3D points from camera node outputs containing charuco observations.-- :param camera_node_outputs: Dictionary mapping camera IDs to their output messages- :param undistort_points: If True, undistort points before triangulation- :param compute_reprojection_error: Whether to compute reprojection errors- :return: Tuple of (points3d, mean_errors)- - points3d: Shape (M, 3) - triangulated 3D points for each charuco corner- - mean_errors: Shape (M,) - mean reprojection error per point (pixels), or None- """- points2d_list: list[np.ndarray] = []-- for camera_name in self.camera_names:- if camera_name not in camera_node_outputs:- raise ValueError(f"Camera '{camera_name}' not found in camera_node_outputs")-- camera_output = camera_node_outputs[camera_name]-- if camera_output.observation is None:- raise ValueError(f"Camera '{camera_name}' has no charuco_observation")-- points2d_camera = camera_output.observation.to_2d_array()- points2d_list.append(points2d_camera)-- points2d_stacked = np.stack(points2d_list, axis=0)- points2d = np.transpose(points2d_stacked, (1, 0, 2))-- return self.triangulate_points(- points2d=points2d,- undistort_points=undistort_points,- compute_reprojection_error=compute_reprojection_error- )-- def triangulate_points(- self,- points2d: np.ndarray,- undistort_points: bool = False,- compute_reprojection_error: bool = True- ) -> tuple[np.ndarray, np.ndarray | None]:- """- Fast array-based triangulation for batch processing.-- :param points2d: Shape (M, N, 2) - M points observed by N cameras (pixel coordinates)- :param preallocated_arrays: Optional pre-allocated arrays (auto-resizes if needed)- :param undistort_points: If True, undistort points before triangulation- :param compute_reprojection_error: Whether to compute reprojection errors- :return: Tuple of (points3d, mean_errors)- - points3d: Shape (M, 3) - triangulated 3D points- - mean_errors: Shape (M,) - mean reprojection error per point (pixels), or None- """- if points2d.ndim != 3 or points2d.shape[2] != 2:- raise ValueError(f"points2d must have shape (M, N, 2), got {points2d.shape}")-- if points2d.shape[1] != self.num_cameras:- raise ValueError(- f"points2d has {points2d.shape[1]} cameras but triangulator "- f"has {self.num_cameras} cameras"- )-- points2d = np.ascontiguousarray(points2d, dtype=np.float64)-- if undistort_points:- for cam_idx, cam_calib in enumerate(self.camera_calibrations.values()):- points2d[:, cam_idx] = cam_calib.undistort_points(points2d[:, cam_idx])-- points3d = _triangulate_batch(- points2d,- self.projection_matrices,- )-- mean_errors = None- if compute_reprojection_error:- mean_errors = self._compute_reprojection_errors(points3d, points2d)-- return points3d, mean_errors-- def _compute_reprojection_errors(- self,- points3d: np.ndarray,- points2d: np.ndarray- ) -> np.ndarray:- """- Compute reprojection errors using OpenCV's projection (handles distortion).-- :param points3d: Shape (M, 3) - triangulated 3D points- :param points2d: Shape (M, N, 2) - original 2D observations- :return: Shape (M,) - mean reprojection error per point across all cameras- """- num_points = points3d.shape[0]- errors = np.zeros(num_points, dtype=np.float64)-- for point_idx in range(num_points):- point_errors = []-- for cam_idx, (cam_name, cam_calib) in enumerate(self.camera_calibrations.items()):- projected = cam_calib.project_3d_to_2d(points3d[point_idx:point_idx + 1])- diff = projected[0] - points2d[point_idx, cam_idx]- error = np.linalg.norm(diff)- point_errors.append(error)-- errors[point_idx] = np.mean(point_errors)-- return errors-- def triangulate_dict(- self,- points2d_by_camera: dict[str, dict[str, tuple[float, float]]],- min_cameras: int = 2,- compute_reprojection_error: bool = False- ) -> dict[str, tuple[float, float, float] | dict]:- """- Dictionary-based triangulation (backward compatible API).-- :param points2d_by_camera: {camera_name: {point_name: (x, y)}}- :param min_cameras: Minimum number of cameras required to triangulate a point- :param compute_reprojection_error: If True, return dict with 'point' and 'error' keys- :return: {point_name: (x, y, z)} or {point_name: {'point': (x,y,z), 'error': float}}- """- if not points2d_by_camera:- return {}-- first_camera = next(iter(points2d_by_camera.values()))- point_names = list(first_camera.keys())-- for cam_name, points in points2d_by_camera.items():- if list(points.keys()) != point_names:- raise ValueError(f"Camera {cam_name} has different point names")-- results = {}-- for point_name in point_names:- observations = []- valid_camera_indices = []-- for cam_idx, cam_name in enumerate(self.camera_names):- if cam_name not in points2d_by_camera:- continue-- point2d = points2d_by_camera[cam_name].get(point_name)- if point2d is None:- continue-- if np.isnan(point2d).any():- continue-- observations.append(point2d)- valid_camera_indices.append(cam_idx)-- if len(observations) < min_cameras:- results[point_name] = (np.nan, np.nan, np.nan)- continue-- points2d_array = np.array([observations], dtype=np.float64)- valid_projection_matrices = self.projection_matrices[valid_camera_indices]-- point3d = _triangulate_batch(points2d_array, valid_projection_matrices)[0]-- if compute_reprojection_error:- errors = []- for cam_idx, obs in zip(valid_camera_indices, observations):- cam_name = self.camera_names[cam_idx]- cam_calib = self.camera_calibrations[cam_name]- projected = cam_calib.project_3d_to_2d(point3d.reshape(1, 3))- error = np.linalg.norm(projected[0] - np.array(obs))- errors.append(error)-- results[point_name] = {- 'point': tuple(point3d),- 'error': float(np.mean(errors))- }- else:- results[point_name] = tuple(point3d)-- return results---def benchmark_triangulator() -> None:- # TODO : implement benchmark- pass---if __name__ == "__main__":- benchmark_triangulator()diff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_video_node.py b/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_video_node.pydeleted file mode 100644index 8e4f623f..00000000--- a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/calibration_video_node.py+++ /dev/null@@ -1,116 +0,0 @@-import logging-import multiprocessing-from dataclasses import dataclass-from pathlib import Path-import cv2-from pydantic import BaseModel, ConfigDict-from skellycam.core.types.type_overloads import WorkerType-from skellytracker.trackers.charuco_tracker.charuco_detector import CharucoDetector--from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.posthoc_calibration_pipeline import \- CalibrationpipelineConfig-from freemocap.core.pipeline.pipeline_ipc import PipelineIPC-from freemocap.core.types.type_overloads import PipelineIdString, VideoIdString-from freemocap.pubsub.pubsub_topics import VideoNodeOutputTopic, VideoNodeOutputMessage--logger = logging.getLogger(__name__)----class VideoNodeState(BaseModel):- model_config = ConfigDict(- validate_assignment=True,- frozen=True- )- pipeline_id: PipelineIdString- alive: bool- last_seen_frame_number: int | None = None- calibration_task_state: object | None = None- mocap_task_state: object = None # TODO - this---@dataclass-class CalibrationVideoNode:- video_id:VideoIdString- video_path:Path- calibration_pipeline_config: CalibrationpipelineConfig- shutdown_self_flag: multiprocessing.Value- worker: WorkerType-- @classmethod- def create(cls,- video_id:VideoIdString,- video_path:Path,- subprocess_registry: list[multiprocessing.Process],- calibration_pipeline_config: CalibrationpipelineConfig,- ipc: PipelineIPC):- shutdown_self_flag = multiprocessing.Value('b', False)- worker = multiprocessing.Process(target=cls._run,- name=f"VideoProcessingNode-{video_path.stem}",- kwargs=dict(video_id=video_id,- video_path=video_path,- ipc=ipc,- calibration_pipeline_config=calibration_pipeline_config,- shutdown_self_flag=shutdown_self_flag,- ),- )- subprocess_registry.append(worker)- return cls(video_id=video_id,- video_path=video_path,- shutdown_self_flag=shutdown_self_flag,- calibration_pipeline_config=calibration_pipeline_config,- worker=worker- )-- @staticmethod- def _run(video_id:VideoIdString,- video_path:Path,- ipc: PipelineIPC,- calibration_pipeline_config: CalibrationpipelineConfig,- shutdown_self_flag: multiprocessing.Value,- ):- if multiprocessing.parent_process():- # Configure logging if multiprocessing (i.e. if there is a parent process)- from freemocap.system.logging_configuration.configure_logging import configure_logging- from freemocap import LOG_LEVEL- configure_logging(LOG_LEVEL, ws_queue=ipc.ws_queue)-- logger.info(f"Starting video processing node for video: {video_path.stem}")-- video_reader = cv2.VideoCapture(str(video_path))- success, image = video_reader.read()- frame_number = 0- charuco_detector = CharucoDetector.create(config=calibration_pipeline_config.detector_config)- try:- while success and not shutdown_self_flag.value and ipc.should_continue:-- charuco_observation = charuco_detector.detect(- frame_number=frame_number,- image=image)-- ipc.pubsub.publish(- topic_type=VideoNodeOutputTopic,- message=VideoNodeOutputMessage(- video_id=video_id,- frame_number=frame_number,- observation=charuco_observation,- ),- )- success, image = video_reader.read()- frame_number += 1- except Exception as e:- logger.exception(f"Exception in video node for video: {video_path.stem} - {e}")- ipc.kill_everything()- raise e- finally:- logger.debug(f"Shutting down video processing node for video: {video_path.stem}")- video_reader.release()-- def start(self):- logger.debug(f"Starting {self.__class__.__name__} for video: {self.video_path.stem}")- self.worker.start()-- def shutdown(self):- logger.debug(f"Stopping {self.__class__.__name__} for video: {self.video_path.stem}")- self.shutdown_self_flag.value = True- self.worker.join()diff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/posthoc_calibration_aggregation_node.py b/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/posthoc_calibration_aggregation_node.pydeleted file mode 100644index fe969509..00000000--- a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/posthoc_calibration_aggregation_node.py+++ /dev/null@@ -1,183 +0,0 @@-import logging-import multiprocessing-from dataclasses import dataclass-from pathlib import Path--from pydantic import BaseModel, ConfigDict-from skellycam.core.recorders.videos.recording_info import RecordingInfo-from skellycam.core.types.type_overloads import TopicSubscriptionQueue, CameraIdString--from skellytracker.trackers.base_tracker.base_tracker_abcs import BaseRecorder-from skellytracker.trackers.charuco_tracker.charuco_observation import CharucoObservation--from freemocap.core.pipeline.pipeline_configs import RealtimePipelineConfig-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.posthoc_calibration_pipeline import \- CalibrationpipelineConfig-from freemocap.core.pipeline.pipeline_ipc import PipelineIPC-from freemocap.core.pipeline.posthoc_pipelines.posthoc_mocap_pipeline.mocap_helpers.charuco_model_from_observations import \- charuco_model_from_observations-from freemocap.core.pipeline.posthoc_pipelines.video_helper import VideoMetadata-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.charuco_observation_aggregator import \- anipose_calibration_from_charuco_observations, get_last_successful_calibration_toml_path--from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.shared_view_accumulator import CharucoObservations-from freemocap.core.types.type_overloads import PipelineIdString, FrameNumberInt, VideoIdString-from freemocap.pubsub.pubsub_topics import VideoNodeOutputMessage, VideoNodeOutputTopic-from freemocap.utilities.wait_functions import wait_1ms--logger = logging.getLogger(__name__)---class PosthocAgregationNodeState(BaseModel):- model_config = ConfigDict(- validate_assignment=True,- frozen=True- )- pipeline_id: PipelineIdString- config: RealtimePipelineConfig- alive: bool- last_seen_frame_number: int | None = None- calibration_task_state: object | None = None- mocap_task_state: object = None # TODO - this---@dataclass-class PosthocCalibrationAggregationNode:- shutdown_self_flag: multiprocessing.Value- worker: multiprocessing.Process-- @classmethod- def create(cls,- calibration_pipeline_config: CalibrationpipelineConfig,- video_metadata: dict[VideoIdString, VideoMetadata],- pipeline_id: PipelineIdString,- recording_info: RecordingInfo,- subprocess_registry: list[multiprocessing.Process],- ipc: PipelineIPC):- shutdown_self_flag = multiprocessing.Value('b', False)- worker = multiprocessing.Process(target=cls._run,- name=f"Pipeline-{pipeline_id}-PosthocAggregationNode",- kwargs=dict(calibration_pipeline_config=calibration_pipeline_config,- pipeline_id=pipeline_id,- recording_info=recording_info,- video_metadata=video_metadata,- ipc=ipc,- shutdown_self_flag=shutdown_self_flag,- video_node_subscription=ipc.pubsub.topics[- VideoNodeOutputTopic].get_subscription(),- ),- )- subprocess_registry.append(worker)- return cls(shutdown_self_flag=shutdown_self_flag,- worker=worker- )-- @staticmethod- def _run(calibration_pipeline_config: CalibrationpipelineConfig,- recording_info: RecordingInfo,- pipeline_id: PipelineIdString,- video_metadata: dict[VideoIdString, VideoMetadata],- ipc: PipelineIPC,- shutdown_self_flag: multiprocessing.Value,- video_node_subscription: TopicSubscriptionQueue,- ):- if multiprocessing.parent_process():- # Configure logging if multiprocessing (i.e. if there is a parent process)- from freemocap.system.logging_configuration.configure_logging import configure_logging- from freemocap import LOG_LEVEL- configure_logging(LOG_LEVEL, ws_queue=ipc.ws_queue)-- start_frame = set(vm.start_frame for vm in video_metadata.values())- end_frame = set(vm.end_frame for vm in video_metadata.values())- if len(start_frame) != 1 or len(end_frame) != 1:- raise ValueError(f"Mismatch in start/end frames across videos in pipeline {pipeline_id}: "- f"start_frames={start_frame}, end_frames={end_frame}")- start_frame = start_frame.pop()- end_frame = end_frame.pop()- frame_numbers = set(range(start_frame, end_frame))- video_ids = list(video_metadata.keys())-- logger.debug(f"PosthocCalibrationAggregationNode for pipeline id: '{pipeline_id}' starting main loop")- try:-- video_outputs_by_frame: dict[FrameNumberInt, dict[VideoIdString, VideoNodeOutputMessage | None]] = {- frame_number: {video_id: None for video_id in video_ids}- for frame_number in frame_numbers- }- got_all_outputs_by_frame = {frame_number: False for frame_number in frame_numbers}-- if not len(video_outputs_by_frame) == len(frame_numbers):- raise ValueError(f"Mismatch between video outputs by frame and recording info frame count - "- f"{len(video_outputs_by_frame)} vs {len(frame_numbers)}")-- while not shutdown_self_flag.value and ipc.should_continue:- wait_1ms()- if not video_node_subscription.empty():- video_node_output_message: VideoNodeOutputMessage = video_node_subscription.get()-- if not video_node_output_message.video_id in video_ids:- raise ValueError(- f"Video ID {video_node_output_message.video_id} not in recording info for pipeline {pipeline_id} - {recording_info.recording_name}")- video_outputs_by_frame[video_node_output_message.frame_number][- video_node_output_message.video_id] = video_node_output_message- if all([isinstance(value, VideoNodeOutputMessage) for value in- video_outputs_by_frame[video_node_output_message.frame_number].values()]):- logger.info(f"Received all video node outputs for frame {video_node_output_message.frame_number} in pipeline {pipeline_id}")- got_all_outputs_by_frame[video_node_output_message.frame_number] = True-- if all(list(got_all_outputs_by_frame.values())):- break- logger.info(f"All video node outputs received for pipeline {pipeline_id}, starting calibration")- charuco_observations_by_frame: list[ dict[CameraIdString, CharucoObservation]] = []- for frame_outputs in video_outputs_by_frame.values():- if not all([isinstance(output, VideoNodeOutputMessage) for output in frame_outputs.values()]):- raise ValueError(- f"Missing video node outputs for frame in pipeline {pipeline_id}: {frame_outputs}")- charuco_observations_by_frame.append({- video_id: output.observation- for video_id, output in frame_outputs.items()- })--- calibration_toml_path = anipose_calibration_from_charuco_observations(- charuco_observations_by_frame=charuco_observations_by_frame,- calibration_pipeline_config=calibration_pipeline_config,- recording_info=recording_info,- video_metadata=video_metadata,- # use_charuco_as_groundplane=True,- )- observation_recorders_by_video = {video_id: BaseRecorder() for video_id in- charuco_observations_by_frame[0].keys()}- for frame_number, charuco_observations_by_camera in enumerate(charuco_observations_by_frame):- if not all(- [isinstance(output, CharucoObservation) for output in charuco_observations_by_camera.values()]):- raise ValueError(- f"Non-CharucoObservation found in frame {frame_number} observations: {charuco_observations_by_camera}")- for video_id, recorder in observation_recorders_by_video.items():- recorder.add_observation(observation=charuco_observations_by_camera[video_id])-- charuco_board_model = charuco_model_from_observations(- observation_recorders=observation_recorders_by_video,- calibration_toml_path=get_last_successful_calibration_toml_path(),- output_data_folder=Path(recording_info.full_recording_path) / "output_data",- )-- logger.success(- f"Posthoc calibration completed for pipeline {pipeline_id}! Calibration file saved to {recording_info.full_recording_path}")--- except Exception as e:- logger.error(f"Exception in PosthocAggregationNode for recording: {recording_info.recording_name}: {e}", exc_info=True)- ipc.kill_everything()- raise- finally:- logger.debug(f"Shutting down aggregation process for recording: {recording_info.recording_name}")-- def start(self):- logger.debug(f"Starting PosthocAggregationNode worker")- self.worker.start()-- def shutdown(self):- logger.debug(f"Stopping PosthocAggregationNode worker")- self.shutdown_self_flag.value = True- self.worker.join()diff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/posthoc_calibration_pipeline.py b/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/posthoc_calibration_pipeline.pydeleted file mode 100644index 88c0ec5f..00000000--- a/freemocap/core/pipeline/posthoc_pipelines/posthoc_calibration_pipeline/posthoc_calibration_pipeline.py+++ /dev/null@@ -1,120 +0,0 @@-import logging-import multiprocessing-import uuid--from pydantic import BaseModel, ConfigDict--from freemocap.core.pipeline.pipeline_configs import CalibrationpipelineConfig-from freemocap.core.pipeline.pipeline_ipc import PipelineIPC-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.posthoc_calibration_aggregation_node import PosthocCalibrationAggregationNode-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_video_node import VideoNodeState, CalibrationVideoNode-from freemocap.core.pipeline.posthoc_pipelines.video_helper import VideoGroupHelper-from freemocap.core.pipeline.realtime_pipeline.realtime_aggregation_node import RealtimeAggregationNodeState-from freemocap.core.types.type_overloads import PipelineIdString, VideoIdString--from skellycam.core.recorders.videos.recording_info import RecordingInfo--logger = logging.getLogger(__name__)---class PosthocPipelineState(BaseModel):- """Serializable representation of a processing pipeline state."""- model_config = ConfigDict(- validate_assignment=True,- frozen=True- )- id: PipelineIdString- video_node_states: dict[VideoIdString, VideoNodeState]- aggregation_node_state: RealtimeAggregationNodeState- alive: bool--class PosthocCalibrationProcessingPipeline(BaseModel):- model_config = ConfigDict(- arbitrary_types_allowed=True,- validate_assignment=True,- extra="forbid",- )- id: PipelineIdString- recording_info:RecordingInfo- calibration_pipeline_config: CalibrationpipelineConfig- video_nodes: dict[VideoIdString, CalibrationVideoNode]- aggregation_node: PosthocCalibrationAggregationNode- ipc: PipelineIPC- started: bool = False-- @property- def alive(self) -> bool:- return all([video_node.worker.is_alive() for video_node in- self.video_nodes.values()]) and self.aggregation_node.worker.is_alive()-- @property- def video_ids(self) -> list[VideoIdString]:- return list(self.video_nodes.keys())-- @classmethod- def from_config(cls,- recording_info:RecordingInfo,- heartbeat_timestamp: multiprocessing.Value,- subprocess_registry: list[multiprocessing.Process],- calibration_pipeline_config: CalibrationpipelineConfig,- global_kill_flag: multiprocessing.Value,- ):- #validate with video_group object- video_group = VideoGroupHelper.from_recording_path(recording_path=recording_info.full_recording_path)- pipeline_id = str(uuid.uuid4())[:6]- ipc = PipelineIPC.create(global_kill_flag=global_kill_flag,- heartbeat_timestamp=heartbeat_timestamp- )- video_nodes = {video_id: CalibrationVideoNode.create(video_id=video_id,- video_path=video_helper.video_path, #recreate in node worker- subprocess_registry=subprocess_registry,- calibration_pipeline_config=calibration_pipeline_config,- ipc=ipc)- for video_id, video_helper in video_group.videos.items()}- aggregation_node = PosthocCalibrationAggregationNode.create(subprocess_registry=subprocess_registry,- calibration_pipeline_config=calibration_pipeline_config,- video_metadata=video_group.video_metadata_by_id,- ipc=ipc,- recording_info=recording_info,- pipeline_id=pipeline_id- )- video_group.close() # close here, videos reopened in video nodes- return cls(video_nodes=video_nodes,- aggregation_node=aggregation_node,- ipc=ipc,- calibration_pipeline_config=calibration_pipeline_config,- id=pipeline_id,- recording_info=recording_info- )-- def start(self) -> None:- self.started = True- logger.debug(f"Starting Pipeline (id:{self.id} with for recording: {self.recording_info.recording_name}")- try:- logger.debug("Starting video nodes...")- [node.start() for node in self.video_nodes.values()]- except Exception as e:- logger.error(f"Failed to start video nodes: {type(e).__name__} - {e}")- logger.exception(e)- raise-- try:- logger.debug("Starting aggregation node...")- self.aggregation_node.start()- logger.debug(f"Aggregation node worker started: alive={self.aggregation_node.worker.is_alive()}")- except Exception as e:- logger.error(f"Failed to start aggregation node: {type(e).__name__} - {e}")- logger.exception(e)- raise--- logger.info(f"All pipeline workers started successfully")-- def shutdown(self):- logger.debug(f"Shutting down {self.__class__.__name__}...")-- self.ipc.shutdown_pipeline()- for video_id, video_node in self.video_nodes.items():- video_node.shutdown()- self.aggregation_node.shutdown()-diff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/mocap_video_node.py b/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/mocap_video_node.pydeleted file mode 100644index 8d2a5df4..00000000--- a/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/mocap_video_node.py+++ /dev/null@@ -1,103 +0,0 @@-import logging-import multiprocessing-from dataclasses import dataclass-from pathlib import Path-import cv2--from skellycam.core.types.type_overloads import WorkerType-from skellytracker.trackers.mediapipe_tracker.mediapipe_detector import MediapipeDetector--from freemocap.core.pipeline.pipeline_ipc import PipelineIPC-from freemocap.core.pipeline.posthoc_pipelines.posthoc_mocap_pipeline.posthoc_mocap_pipeline import \- MocapPipelineTaskConfig--from freemocap.core.types.type_overloads import VideoIdString-from freemocap.pubsub.pubsub_topics import VideoNodeOutputTopic, VideoNodeOutputMessage--logger = logging.getLogger(__name__)---@dataclass-class MocapVideoNode:- video_id: VideoIdString- video_path: Path- mocap_task_config: MocapPipelineTaskConfig- shutdown_self_flag: multiprocessing.Value- worker: WorkerType-- @classmethod- def create(cls,- video_id: VideoIdString,- video_path: Path,- subprocess_registry: list[multiprocessing.Process],- mocap_task_config: MocapPipelineTaskConfig,- ipc: PipelineIPC):- shutdown_self_flag = multiprocessing.Value('b', False)- worker = multiprocessing.Process(target=cls._run,- name=f"VideoProcessingNode-{video_path.stem}",- kwargs=dict(- video_id=video_id,- video_path=video_path,- ipc=ipc,- mocap_task_config=mocap_task_config,- shutdown_self_flag=shutdown_self_flag,- ),- )- subprocess_registry.append(worker)- return cls(video_id=video_id,- video_path=video_path,- shutdown_self_flag=shutdown_self_flag,- mocap_task_config=mocap_task_config,- worker=worker- )-- @staticmethod- def _run(video_id: VideoIdString,- video_path: Path,- ipc: PipelineIPC,- mocap_task_config: MocapPipelineTaskConfig,- shutdown_self_flag: multiprocessing.Value,- ):- if multiprocessing.parent_process():- # Configure logging if multiprocessing (i.e. if there is a parent process)- from freemocap.system.logging_configuration.configure_logging import configure_logging- from freemocap import LOG_LEVEL- configure_logging(LOG_LEVEL, ws_queue=ipc.ws_queue)-- video_reader = cv2.VideoCapture(str(video_path))- success, image = video_reader.read()- frame_number = 0- logger.info(f"Starting video processing node for video: {video_path.stem}")- mediapipe_detector = MediapipeDetector.create(config=mocap_task_config.detector_config)- try:- while success and not shutdown_self_flag.value and ipc.should_continue:- mediapipe_observation = mediapipe_detector.detect(- frame_number=frame_number,- image=image)-- ipc.pubsub.publish(- topic_type=VideoNodeOutputTopic,- message=VideoNodeOutputMessage(- video_id=video_id,- frame_number=frame_number,- observation=mediapipe_observation,- ),- )- success, image = video_reader.read()- frame_number+=1-- except Exception as e:- logger.exception(f"Exception in video node for video: {video_path.stem} - {e}")- ipc.kill_everything()- raise e- finally:- logger.debug(f"Shutting down video processing node for video: {video_path.stem}")- video_reader.release()- def start(self):- logger.debug(f"Starting {self.__class__.__name__} for video: {self.video_path.stem}")- self.worker.start()-- def shutdown(self):- logger.debug(f"Stopping {self.__class__.__name__} for video: {self.video_path.stem}")- self.shutdown_self_flag.value = True- self.worker.join()diff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/posthoc_mocap_aggregation_node.py b/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/posthoc_mocap_aggregation_node.pydeleted file mode 100644index 306848c0..00000000--- a/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/posthoc_mocap_aggregation_node.py+++ /dev/null@@ -1,167 +0,0 @@-import logging-import multiprocessing-from dataclasses import dataclass-from pathlib import Path--from pydantic import BaseModel, ConfigDict--from skellycam.core.recorders.videos.recording_info import RecordingInfo-from skellycam.core.types.type_overloads import TopicSubscriptionQueue--from skellytracker.trackers.mediapipe_tracker.mediapipe_observation import MediapipeObservation-from skellytracker.trackers.base_tracker.base_tracker_abcs import BaseRecorder--from freemocap.core.pipeline.pipeline_configs import RealtimePipelineConfig-from freemocap.core.pipeline.pipeline_ipc import PipelineIPC-from freemocap.core.pipeline.posthoc_pipelines.posthoc_mocap_pipeline.posthoc_mocap_pipeline import \- MocapPipelineTaskConfig-from freemocap.core.pipeline.posthoc_pipelines.posthoc_mocap_pipeline.mocap_helpers.skeleton_from_mediapipe_observations import \- skeleton_from_mediapipe_observation_recorders-from freemocap.core.pipeline.posthoc_pipelines.video_helper import VideoMetadata-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.charuco_observation_aggregator import \- get_last_successful_calibration_toml_path-from freemocap.core.types.type_overloads import PipelineIdString, FrameNumberInt, VideoIdString-from freemocap.pubsub.pubsub_topics import VideoNodeOutputMessage, VideoNodeOutputTopic-from freemocap.utilities.wait_functions import wait_1ms--logger = logging.getLogger(__name__)--MediapipeObservations = dict[VideoIdString, MediapipeObservation]---class PosthocAgregationNodeState(BaseModel):- model_config = ConfigDict(- validate_assignment=True,- frozen=True- )- pipeline_id: PipelineIdString- config: RealtimePipelineConfig- alive: bool- last_seen_frame_number: int | None = None- mocap_task_state: object | None = None- mocap_task_state: object = None # TODO - this---@dataclass-class PosthocMocapAggregationNode:- shutdown_self_flag: multiprocessing.Value- worker: multiprocessing.Process-- @classmethod- def create(cls,- mocap_task_config: MocapPipelineTaskConfig,- video_metadata: dict[VideoIdString, VideoMetadata],- pipeline_id: PipelineIdString,- recording_info: RecordingInfo,- subprocess_registry: list[multiprocessing.Process],- ipc: PipelineIPC):- shutdown_self_flag = multiprocessing.Value('b', False)- worker = multiprocessing.Process(target=cls._run,- name=f"Pipeline-{pipeline_id}-PosthocAggregationNode",- kwargs=dict(mocap_task_config=mocap_task_config,- pipeline_id=pipeline_id,- recording_info=recording_info,- video_metadata=video_metadata,- ipc=ipc,- shutdown_self_flag=shutdown_self_flag,- video_node_subscription=ipc.pubsub.topics[- VideoNodeOutputTopic].get_subscription(),- ),- )- subprocess_registry.append(worker)- return cls(shutdown_self_flag=shutdown_self_flag,- worker=worker- )-- @staticmethod- def _run(mocap_task_config: MocapPipelineTaskConfig,- recording_info: RecordingInfo,- pipeline_id: PipelineIdString,- video_metadata: dict[VideoIdString, VideoMetadata],- ipc: PipelineIPC,- shutdown_self_flag: multiprocessing.Value,- video_node_subscription: TopicSubscriptionQueue,- ):- if multiprocessing.parent_process():- # Configure logging if multiprocessing (i.e. if there is a parent process)- from freemocap.system.logging_configuration.configure_logging import configure_logging- from freemocap import LOG_LEVEL- configure_logging(LOG_LEVEL, ws_queue=ipc.ws_queue)-- start_frame = set(vm.start_frame for vm in video_metadata.values())- end_frame = set(vm.end_frame for vm in video_metadata.values())- if len(start_frame) != 1 or len(end_frame) != 1:- raise ValueError(f"Mismatch in start/end frames across videos in pipeline {pipeline_id}: "- f"start_frames={start_frame}, end_frames={end_frame}")- start_frame = start_frame.pop()- end_frame = end_frame.pop()- frame_numbers = set(range(start_frame, end_frame))- video_ids = list(video_metadata.keys())-- logger.debug(f"PosthocMocapAggregationNode for pipeline id: '{pipeline_id}' starting main loop")- try:-- video_outputs_by_frame: dict[FrameNumberInt, dict[VideoIdString, VideoNodeOutputMessage | None]] = {- frame_number: {video_id: None for video_id in video_ids}- for frame_number in frame_numbers- }- got_all_outputs_by_frame = {frame_number: False for frame_number in frame_numbers}-- if not len(video_outputs_by_frame) == len(frame_numbers):- raise ValueError(f"Mismatch between video outputs by frame and recording info frame count - "- f"{len(video_outputs_by_frame)} vs {len(frame_numbers)}")-- while not shutdown_self_flag.value and ipc.should_continue:- wait_1ms()- if not video_node_subscription.empty():- video_node_output_message: VideoNodeOutputMessage = video_node_subscription.get()-- if not video_node_output_message.video_id in video_ids:- raise ValueError(- f"Video ID {video_node_output_message.video_id} not in recording info for pipeline {pipeline_id} - {recording_info.recording_name}")- video_outputs_by_frame[video_node_output_message.frame_number][- video_node_output_message.video_id] = video_node_output_message- if all([isinstance(value, VideoNodeOutputMessage) for value in- video_outputs_by_frame[video_node_output_message.frame_number].values()]):- logger.info(- f"Received all video node outputs for frame {video_node_output_message.frame_number} in pipeline {pipeline_id}")- got_all_outputs_by_frame[video_node_output_message.frame_number] = True-- if all(list(got_all_outputs_by_frame.values())):- break- logger.info(f"All video node outputs received for pipeline {pipeline_id}, starting calibration")- observation_recorders_by_video = {video_id: BaseRecorder() for video_id in video_ids}- for frame_number, frame_outputs_by_video in video_outputs_by_frame.items():- if not all([isinstance(output, VideoNodeOutputMessage) for output in frame_outputs_by_video.values()]):- raise ValueError(- f"Missing video node outputs for frame in pipeline {pipeline_id}: {frame_number}")- for video_id, recorder in observation_recorders_by_video.items():- observation = frame_outputs_by_video[video_id].observation- recorder.add_observation(observation=observation)-- skeleton = skeleton_from_mediapipe_observation_recorders(- observation_recorders=observation_recorders_by_video,- path_to_calibration_toml= get_last_successful_calibration_toml_path(),- path_to_output_data_folder=Path(recording_info.full_recording_path)/'output_data',- )-- logger.success(- f"Posthoc calibration completed for pipeline {pipeline_id}! Mocap file saved to {recording_info.full_recording_path}")--- except Exception as e:- logger.error(f"Exception in PosthocAggregationNode for recording: {recording_info.recording_name}: {e}",- exc_info=True)- ipc.kill_everything()- raise- finally:- logger.debug(f"Shutting down aggregation process for recording: {recording_info.recording_name}")-- def start(self):- logger.debug(f"Starting PosthocAggregationNode worker")- self.worker.start()-- def shutdown(self):- logger.debug(f"Stopping PosthocAggregationNode worker")- self.shutdown_self_flag.value = True- self.worker.join()diff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/posthoc_mocap_pipeline.py b/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/posthoc_mocap_pipeline.pydeleted file mode 100644index d2f582a4..00000000--- a/freemocap/core/pipeline/posthoc_pipelines/posthoc_mocap_pipeline/posthoc_mocap_pipeline.py+++ /dev/null@@ -1,106 +0,0 @@-import logging-import multiprocessing-import uuid--from pydantic import BaseModel, ConfigDict-from skellycam.core.recorders.videos.recording_info import RecordingInfo--from freemocap.core.pipeline.pipeline_configs import MocapPipelineTaskConfig-from freemocap.core.pipeline.pipeline_ipc import PipelineIPC-from freemocap.core.pipeline.posthoc_pipelines.posthoc_mocap_pipeline.mocap_video_node import MocapVideoNode-from freemocap.core.pipeline.posthoc_pipelines.posthoc_mocap_pipeline.posthoc_mocap_aggregation_node import \- PosthocMocapAggregationNode-from freemocap.core.pipeline.posthoc_pipelines.video_helper import VideoGroupHelper-from freemocap.core.types.type_overloads import PipelineIdString, VideoIdString--logger = logging.getLogger(__name__)---class PosthocMocapProcessingPipeline(BaseModel):- model_config = ConfigDict(- arbitrary_types_allowed=True,- validate_assignment=True,- extra="forbid",- )- id: PipelineIdString- recording_info: RecordingInfo- mocap_task_config: MocapPipelineTaskConfig- video_nodes: dict[VideoIdString, MocapVideoNode]- aggregation_node: PosthocMocapAggregationNode- ipc: PipelineIPC- started: bool = False-- @property- def alive(self) -> bool:- return all([video_node.worker.is_alive() for video_node in- self.video_nodes.values()]) and self.aggregation_node.worker.is_alive()-- @property- def video_ids(self) -> list[VideoIdString]:- return list(self.video_nodes.keys())-- @classmethod- def from_task_config(cls,- recording_info: RecordingInfo,- heartbeat_timestamp: multiprocessing.Value,- subprocess_registry: list[multiprocessing.Process],- mocap_task_config: MocapPipelineTaskConfig,- global_kill_flag: multiprocessing.Value,- ):- # validate by creating video_group object- video_group = VideoGroupHelper.from_recording_path(recording_path=recording_info.full_recording_path)- pipeline_id = str(uuid.uuid4())[:6]- ipc = PipelineIPC.create(global_kill_flag=global_kill_flag,- heartbeat_timestamp=heartbeat_timestamp- )- video_nodes = {video_id: MocapVideoNode.create(video_id=video_id,- video_path=video_helper.video_path, # recreate in node worker- subprocess_registry=subprocess_registry,- mocap_task_config=mocap_task_config,- ipc=ipc)- for video_id, video_helper in video_group.videos.items()}- aggregation_node = PosthocMocapAggregationNode.create(subprocess_registry=subprocess_registry,- mocap_task_config=mocap_task_config,- video_metadata=video_group.video_metadata_by_id,- ipc=ipc,- recording_info=recording_info,- pipeline_id=pipeline_id- )- video_group.close() # close here, videos reopened in video nodes- return cls(video_nodes=video_nodes,- aggregation_node=aggregation_node,- ipc=ipc,- mocap_task_config=mocap_task_config,- id=pipeline_id,- recording_info=recording_info- )-- def start(self) -> None:- self.started = True- logger.debug(f"Starting Pipeline (id:{self.id} with for recording: {self.recording_info.recording_name}")- try:- logger.debug("Starting video nodes...")- [node.start() for node in self.video_nodes.values()]- except Exception as e:- logger.error(f"Failed to start video nodes: {type(e).__name__} - {e}")- logger.exception(e)- raise-- try:- logger.debug("Starting aggregation node...")- self.aggregation_node.start()- logger.debug(f"Aggregation node worker started: alive={self.aggregation_node.worker.is_alive()}")- except Exception as e:- logger.error(f"Failed to start aggregation node: {type(e).__name__} - {e}")- logger.exception(e)- raise-- logger.info(f"All pipeline workers started successfully")-- def shutdown(self):- logger.debug(f"Shutting down {self.__class__.__name__}...")-- self.ipc.shutdown_pipeline()- for video_id, video_node in self.video_nodes.items():- video_node.shutdown()- self.aggregation_node.shutdown()diff --git a/freemocap/core/pipeline/posthoc_pipelines/posthoc_pipeline_manager.py b/freemocap/core/pipeline/posthoc_pipelines/posthoc_pipeline_manager.pydeleted file mode 100644index f53230cb..00000000--- a/freemocap/core/pipeline/posthoc_pipelines/posthoc_pipeline_manager.py+++ /dev/null@@ -1,69 +0,0 @@-import logging-import multiprocessing-from dataclasses import dataclass, field--from fastapi import FastAPI-from skellycam.core.recorders.videos.recording_info import RecordingInfo--from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.posthoc_calibration_pipeline import \- CalibrationpipelineConfig, PosthocCalibrationProcessingPipeline-from freemocap.core.pipeline.posthoc_pipelines.posthoc_mocap_pipeline.posthoc_mocap_pipeline import MocapPipelineTaskConfig, \- PosthocMocapProcessingPipeline-from freemocap.core.types.type_overloads import PipelineIdString--logger = logging.getLogger(__name__)---@dataclass-class PosthocPipelineManager:- global_kill_flag: multiprocessing.Value- heartbeat_timestamp: multiprocessing.Value- subprocess_registry: list[multiprocessing.Process]- lock: multiprocessing.Lock = field(default_factory=multiprocessing.Lock)- posthoc_pipelines: dict[PipelineIdString, PosthocCalibrationProcessingPipeline|PosthocMocapProcessingPipeline] = field(default_factory=dict)-- @classmethod- def from_fastapi_app(cls, fastapi_app: FastAPI):- return cls(global_kill_flag=fastapi_app.state.global_kill_flag,- heartbeat_timestamp=fastapi_app.state.heartbeat_timestamp,- subprocess_registry=fastapi_app.state.subprocess_registry)-- async def create_posthoc_calibration_pipeline(self,- recording_info: RecordingInfo,- calibration_pipeline_config: CalibrationpipelineConfig) -> PosthocCalibrationProcessingPipeline:- with self.lock:- pipeline = PosthocCalibrationProcessingPipeline.from_config(- calibration_pipeline_config=calibration_pipeline_config,- recording_info=recording_info,- heartbeat_timestamp=self.heartbeat_timestamp,- subprocess_registry=self.subprocess_registry,- global_kill_flag=self.global_kill_flag,- )- pipeline.start()- self.posthoc_pipelines[pipeline.id] = pipeline- logger.info(- f"Post-hoc pipeline with ID: {pipeline.id} for recording '{recording_info.recording_name}' created successfully")- return pipeline-- async def create_posthoc_mocap_pipeline(self, recording_info:RecordingInfo, mocap_task_config:MocapPipelineTaskConfig):- with self.lock:- pipeline = PosthocMocapProcessingPipeline.from_task_config(- mocap_task_config=mocap_task_config,- recording_info=recording_info,- heartbeat_timestamp=self.heartbeat_timestamp,- subprocess_registry=self.subprocess_registry,- global_kill_flag=self.global_kill_flag,- )- pipeline.start()- self.posthoc_pipelines[pipeline.id] = pipeline- logger.info(- f"Post-hoc pipeline with ID: {pipeline.id} for recording '{recording_info.recording_name}' created successfully")- return pipeline-- def close_all_posthoc_pipelines(self):- with self.lock:- for pipeline in self.posthoc_pipelines.values():- pipeline.shutdown()- self.posthoc_pipelines.clear()- logger.info("All pipelines closed successfully")-diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/__init__.py b/freemocap/core/pipeline/realtime/__init__.pysimilarity index 100%rename from freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/__init__.pyrename to freemocap/core/pipeline/realtime/__init__.pydiff --git a/freemocap/core/pipeline/realtime/realtime_aggregation_node.py b/freemocap/core/pipeline/realtime/realtime_aggregation_node.pynew file mode 100644index 00000000..4c36fbdb--- /dev/null+++ b/freemocap/core/pipeline/realtime/realtime_aggregation_node.py@@ -0,0 +1,406 @@+"""+RealtimeAggregationNode: collects per-camera observations for each frame,+triangulates mediapipe and charuco observations (if calibration is valid),+filters+constrains the triangulated skeleton via One Euro + FABRIK,+and publishes aggregated output.++Uses CalibrationStateTracker for graceful degradation: if triangulation fails+repeatedly, the calibration is invalidated and we continue publishing 2D-only+data until a new calibration file appears on disk.++Calibration hot-reload: the node polls the calibration file on disk once per+second. If the file has changed (e.g. after posthoc calibration completes),+the new calibration is loaded and the skeleton filter + velocity gate are reset.++Skeleton filtering (One Euro + FABRIK) runs on the triangulated 3D mediapipe+points. Bone lengths are estimated online from observed inter-keypoint distances+blended with an anthropometric prior. The filter resets on calibration reload+since the coordinate frame may change.+"""+import logging+import multiprocessing+import time+from dataclasses import dataclass++import numpy as np+from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry+from skellyforge.data_models.trajectory_3d import Point3d+from skellycam.core.ipc.shared_memory.camera_group_shared_memory import (+ CameraGroupSharedMemory,+ CameraGroupSharedMemoryDTO,+)+from skellycam.core.types.type_overloads import CameraGroupIdString, CameraIdString, TopicSubscriptionQueue+from skellycam.utilities.wait_functions import wait_1ms++from freemocap.core.calibration.shared.calibration_state import CalibrationStateTracker+from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.bone_length_estimator import AnthropometricPrior+from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.mediapipe_skeleton_config import SkeletonDefinition+from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.realtime_point_gate import RealtimePointGate, GateResult+from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.rigid_body_estimator import estimate_rigid_bodies, RigidBodyPose+from freemocap.core.mocap.skeleton_dewiggler.realtime_skeleton_filter import RealtimeFilterConfig, \+ RealtimeSkeletonFilter, FilterResult++from freemocap.core.pipeline.base_node import BaseNode+from freemocap.core.pipeline.pipeline_configs import RealtimePipelineConfig+from freemocap.core.pipeline.pipeline_ipc import PipelineIPC+from freemocap.core.types.type_overloads import TopicPublicationQueue+from freemocap.pubsub.pubsub_manager import PubSubTopicManager+from freemocap.pubsub.pubsub_topics import (+ CameraNodeOutputMessage,+ CameraNodeOutputTopic,+ PipelineConfigUpdateTopic,+ ProcessFrameNumberTopic,+ ProcessFrameNumberMessage,+ AggregationNodeOutputMessage,+ AggregationNodeOutputTopic,+ PipelineConfigUpdateMessage,+)++logger = logging.getLogger(__name__)++# How often (seconds) to poll the calibration file for changes+CALIBRATION_POLL_INTERVAL_SECONDS: float = 1.0+++def _merge_triangulated_arrays(+ *,+ triangulated: dict[str, np.ndarray] | None,+ into: dict[str, np.ndarray],+) -> None:+ """Merge triangulated 3D point arrays into the output dict, skipping NaN entries."""+ if triangulated is None:+ return+ for point_name, coords in triangulated.items():+ if not isinstance(coords, np.ndarray):+ raise TypeError(+ f"Unexpected type for triangulated point '{point_name}': "+ f"{type(coords).__name__} (expected np.ndarray)"+ )+ if np.any(np.isnan(coords)):+ continue+ into[point_name] = coords+++def _arrays_to_point3d(arrays: dict[str, np.ndarray]) -> dict[str, Point3d]:+ """Convert dict of {name: ndarray(3,)} to dict of {name: Point3d}. Done once at the end."""+ return {+ name: Point3d(x=float(arr[0]), y=float(arr[1]), z=float(arr[2]))+ for name, arr in arrays.items()+ }+++def _create_skeleton_filter(+ *,+ filter_config: RealtimeFilterConfig,+) -> RealtimeSkeletonFilter:+ """Create the skeleton filter with mediapipe body skeleton and anthropometric prior."""+ skeleton = SkeletonDefinition.mediapipe_body()+ prior = AnthropometricPrior.mediapipe_body()+ return RealtimeSkeletonFilter.create(+ skeleton=skeleton,+ prior=prior,+ config=filter_config,+ )+++def _filter_skeleton_arrays(+ *,+ point_arrays: dict[str, np.ndarray],+ skeleton_filter: RealtimeSkeletonFilter,+ t: float,+) -> dict[str, np.ndarray]:+ """+ Run the skeleton filter on triangulated point arrays, returning filtered results.++ Operates entirely on dict[str, ndarray] — no Point3d conversion.+ """+ skeleton_keypoint_names = skeleton_filter.skeleton.keypoint_names++ skeleton_positions: dict[str, np.ndarray] = {+ name: arr for name, arr in point_arrays.items()+ if name in skeleton_keypoint_names+ }++ if not skeleton_positions:+ return point_arrays++ filter_result: FilterResult = skeleton_filter.process_frame(+ t=t,+ positions=skeleton_positions,+ )++ # Build output: filtered skeleton + unmodified non-skeleton points+ result: dict[str, np.ndarray] = {}+ for name, arr in point_arrays.items():+ if name in filter_result.positions:+ result[name] = filter_result.positions[name]+ else:+ result[name] = arr++ # Add predicted keypoints that weren't in this frame+ for name in filter_result.predicted_names:+ if name not in result and name in filter_result.positions:+ result[name] = filter_result.positions[name]++ return result+++@dataclass+class RealtimeAggregationNode(BaseNode):++ @classmethod+ def create(+ cls,+ *,+ config: RealtimePipelineConfig,+ camera_group_id: CameraGroupIdString,+ worker_registry: WorkerRegistry,+ camera_group_shm_dto: CameraGroupSharedMemoryDTO,+ ipc: PipelineIPC,+ pubsub: PubSubTopicManager,+ ) -> "RealtimeAggregationNode":+ shutdown_self_flag, worker = cls._create_worker(+ target=cls._run,+ name=f"CameraGroup-{camera_group_id}-AggregationNode",+ worker_registry=worker_registry,+ log_queue=ipc.ws_queue,+ kwargs=dict(+ config=config,+ camera_group_id=camera_group_id,+ ipc=ipc,+ camera_group_shm_dto=camera_group_shm_dto,+ camera_node_sub=pubsub.get_subscription(+ CameraNodeOutputTopic,+ ),+ pipeline_config_sub=pubsub.get_subscription(+ PipelineConfigUpdateTopic,+ ),+ process_frame_number_pub=pubsub.get_publication_queue(+ ProcessFrameNumberTopic,+ ),+ aggregation_output_pub=pubsub.get_publication_queue(+ AggregationNodeOutputTopic,+ ),+ ),+ )+ return cls(+ shutdown_self_flag=shutdown_self_flag,+ worker=worker,+ )++ @staticmethod+ def _run(+ *,+ config: RealtimePipelineConfig,+ camera_group_id: CameraGroupIdString,+ ipc: PipelineIPC,+ shutdown_self_flag: multiprocessing.Value,+ camera_group_shm_dto: CameraGroupSharedMemoryDTO,+ camera_node_sub: TopicSubscriptionQueue,+ pipeline_config_sub: TopicSubscriptionQueue,+ process_frame_number_pub: TopicPublicationQueue,+ aggregation_output_pub: TopicPublicationQueue,+ ) -> None:+ logger.debug(f"RealtimeAggregationNode [{camera_group_id}] initializing")++ camera_group_shm = CameraGroupSharedMemory.recreate(+ shm_dto=camera_group_shm_dto,+ read_only=True,+ )+ calibration = CalibrationStateTracker.create_and_try_load()+ if calibration.is_valid:+ logger.info(+ f"RealtimeAggregationNode [{camera_group_id}] loaded calibration "+ f"from {calibration.calibration_path}"+ )+ else:+ logger.info(+ f"RealtimeAggregationNode [{camera_group_id}] starting without "+ f"calibration — triangulation disabled"+ )++ # Initialize skeleton filter for 3D smoothing + bone length constraint+ filter_config = config.mocap_config.skeleton_filter+ skeleton_filter = _create_skeleton_filter(filter_config=filter_config)++ # Initialize velocity gate for rejecting teleportation spikes+ point_gate = RealtimePointGate(+ max_velocity_m_per_s=filter_config.max_velocity_m_per_s,+ max_rejected_streak=filter_config.max_rejected_streak,+ )++ camera_node_outputs: dict[CameraIdString, CameraNodeOutputMessage | None] = {+ cam_id: None for cam_id in config.camera_configs.keys()+ }+ latest_requested_frame: int = -1+ last_received_frame: int = -1+ last_calibration_poll: float = time.monotonic()++ try:+ logger.debug(f"RealtimeAggregationNode [{camera_group_id}] entering main loop")+ while ipc.should_continue and not shutdown_self_flag.value:+ wait_1ms()++ # ---- Handle config updates ----+ while not pipeline_config_sub.empty():+ msg: PipelineConfigUpdateMessage = pipeline_config_sub.get()+ config = msg.pipeline_config+ filter_config = config.mocap_config.skeleton_filter+ logger.info(+ f"RealtimeAggregationNode [{camera_group_id}] received config update"+ )++ # ---- Periodically check if calibration file changed on disk ----+ now = time.monotonic()+ if now - last_calibration_poll >= CALIBRATION_POLL_INTERVAL_SECONDS:+ last_calibration_poll = now+ if calibration.check_for_update():+ logger.info(+ f"RealtimeAggregationNode [{camera_group_id}] "+ f"hot-reloaded calibration from {calibration.calibration_path}"+ )+ # Coordinate frame may have changed — reset filter + gate+ skeleton_filter.reset()+ point_gate.reset()++ # ---- Request new frames if ready ----+ if not camera_group_shm.valid:+ logger.debug(+ f"RealtimeAggregationNode [{camera_group_id}] "+ f"shared memory invalidated, exiting"+ )+ break+ current_multiframe_number = camera_group_shm.latest_multiframe_number+ if (current_multiframe_number > latest_requested_frame+ and last_received_frame >= latest_requested_frame):+ process_frame_number_pub.put(+ ProcessFrameNumberMessage(+ frame_number=current_multiframe_number,+ ),+ )+ latest_requested_frame = current_multiframe_number++ # ---- Collect camera node outputs ----+ if camera_node_sub.empty():+ continue++ cam_output: CameraNodeOutputMessage = camera_node_sub.get()+ if cam_output.camera_id not in config.camera_configs:+ raise ValueError(+ f"Camera ID {cam_output.camera_id} not in "+ f"camera IDs {list(config.camera_configs.keys())}"+ )+ camera_node_outputs[cam_output.camera_id] = cam_output++ # ---- Check if all cameras reported for this frame ----+ if not all(+ isinstance(v, CameraNodeOutputMessage)+ for v in camera_node_outputs.values()+ ):+ continue++ frame_numbers = [+ msg.frame_number+ for msg in camera_node_outputs.values()+ if isinstance(msg, CameraNodeOutputMessage)+ ]+ if len(set(frame_numbers)) > 1:+ raise ValueError(+ f"Frame number mismatch across cameras: {frame_numbers} "+ f"(expected {latest_requested_frame})"+ )++ last_received_frame = latest_requested_frame++ # ---- Triangulate and process if calibration is valid ----+ # All processing stays in dict[str, ndarray] until final+ # conversion to Point3d for the output message.+ point_arrays: dict[str, np.ndarray] = {}+ rigid_body_poses: dict[str, RigidBodyPose] = {}++ if calibration.is_valid:+ # Triangulate mediapipe observations+ mediapipe_observations_by_camera = {+ cam_id: output.mediapipe_observation+ for cam_id, output in camera_node_outputs.items()+ if isinstance(output, CameraNodeOutputMessage)+ and output.mediapipe_observation is not None+ }+ if mediapipe_observations_by_camera:+ _merge_triangulated_arrays(+ triangulated=calibration.try_triangulate(+ frame_number=latest_requested_frame,+ frame_observations_by_camera=mediapipe_observations_by_camera,+ max_reprojection_error_px=filter_config.max_reprojection_error_px,+ ),+ into=point_arrays,+ )++ # Triangulate charuco observations+ charuco_observations_by_camera = {+ cam_id: output.charuco_observation+ for cam_id, output in camera_node_outputs.items()+ if isinstance(output, CameraNodeOutputMessage)+ and output.charuco_observation is not None+ }+ if charuco_observations_by_camera:+ _merge_triangulated_arrays(+ triangulated=calibration.try_triangulate(+ frame_number=latest_requested_frame,+ frame_observations_by_camera=charuco_observations_by_camera,+ max_reprojection_error_px=filter_config.max_reprojection_error_px,+ ),+ into=point_arrays,+ )++ # Velocity gate: reject teleportation spikes+ if point_arrays:+ gate_result: GateResult = point_gate.gate(+ t=time.monotonic(),+ points=point_arrays,+ )+ point_arrays = dict(gate_result.positions)++ # Filter + constrain skeleton keypoints+ if point_arrays:+ point_arrays = _filter_skeleton_arrays(+ point_arrays=point_arrays,+ skeleton_filter=skeleton_filter,+ t=time.monotonic(),+ )++ # Estimate rigid body segment poses+ if point_arrays and skeleton_filter.current_bone_lengths:+ rigid_body_poses = estimate_rigid_bodies(+ positions=point_arrays,+ skeleton=skeleton_filter.skeleton,+ bone_lengths=skeleton_filter.current_bone_lengths,+ )++ # Convert to Point3d once at the end for the output message+ tracked_points3d: dict[str, Point3d] = _arrays_to_point3d(point_arrays)++ # ---- Publish aggregated output ----+ aggregation_output_pub.put(+ AggregationNodeOutputMessage(+ frame_number=latest_requested_frame,+ pipeline_id=ipc.pipeline_id,+ camera_group_id=camera_group_id,+ pipeline_config=config,+ camera_node_outputs=camera_node_outputs,+ tracked_points3d=tracked_points3d,+ rigid_body_poses=rigid_body_poses,+ ),+ )++ camera_node_outputs = {cam_id: None for cam_id in config.camera_configs.keys()}++ except Exception as e:+ logger.error(+ f"Exception in RealtimeAggregationNode [{camera_group_id}]: {e}",+ exc_info=True,+ )+ ipc.kill_everything()+ raise+ finally:+ logger.debug(f"RealtimeAggregationNode [{camera_group_id}] exiting")\ No newline at end of filediff --git a/freemocap/core/pipeline/realtime/realtime_camera_node.py b/freemocap/core/pipeline/realtime/realtime_camera_node.pynew file mode 100644index 00000000..c6a06fde--- /dev/null+++ b/freemocap/core/pipeline/realtime/realtime_camera_node.py@@ -0,0 +1,206 @@+"""+RealtimeCameraNode: reads frames from shared memory, runs enabled detectors,+publishes CameraNodeOutputMessages.++Runs indefinitely until shutdown. Responds to pipeline config updates+(toggling detectors, changing charuco board params, etc).+"""+import logging+import multiprocessing+from dataclasses import dataclass++from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry+from skellycam.core.ipc.shared_memory.camera_shared_memory_ring_buffer import CameraSharedMemoryRingBuffer+from skellycam.core.ipc.shared_memory.ring_buffer_shared_memory import SharedMemoryRingBufferDTO+from skellycam.core.types.type_overloads import CameraIdString, TopicSubscriptionQueue+from skellycam.utilities.wait_functions import wait_1ms++from freemocap.core.pipeline.base_node import BaseNode+from freemocap.core.pipeline.pipeline_configs import RealtimePipelineConfig+from freemocap.core.pipeline.pipeline_ipc import PipelineIPC+from freemocap.core.types.type_overloads import TopicPublicationQueue+from freemocap.pubsub.pubsub_manager import PubSubTopicManager+from freemocap.pubsub.pubsub_topics import (+ ProcessFrameNumberTopic,+ PipelineConfigUpdateTopic,+ CameraNodeOutputTopic,+ PipelineConfigUpdateMessage,+ ProcessFrameNumberMessage,+ CameraNodeOutputMessage,+)+from typing import TYPE_CHECKING++if TYPE_CHECKING:+ import numpy as np++logger = logging.getLogger(__name__)+++@dataclass+class RealtimeCameraNode(BaseNode):+ camera_id: CameraIdString++ @classmethod+ def create(+ cls,+ *,+ camera_id: CameraIdString,+ camera_shm_dto: SharedMemoryRingBufferDTO,+ worker_registry: WorkerRegistry,+ config: RealtimePipelineConfig,+ ipc: PipelineIPC,+ pubsub: PubSubTopicManager,+ ) -> "RealtimeCameraNode":+ shutdown_self_flag, worker = cls._create_worker(+ target=cls._run,+ name=f"RealtimeCameraNode-{camera_id}",+ worker_registry=worker_registry,+ log_queue=ipc.ws_queue,+ kwargs=dict(+ camera_id=camera_id,+ ipc=ipc,+ config=config,+ camera_shm_dto=camera_shm_dto,+ process_frame_number_sub=pubsub.get_subscription(+ ProcessFrameNumberTopic,+ ),+ pipeline_config_sub=pubsub.get_subscription(+ PipelineConfigUpdateTopic,+ ),+ camera_output_pub=pubsub.get_publication_queue(+ CameraNodeOutputTopic,+ ),+ ),+ )+ return cls(+ camera_id=camera_id,+ shutdown_self_flag=shutdown_self_flag,+ worker=worker,+ )++ @staticmethod+ def _run(+ *,+ camera_id: CameraIdString,+ ipc: PipelineIPC,+ config: RealtimePipelineConfig,+ process_frame_number_sub: TopicSubscriptionQueue,+ pipeline_config_sub: TopicSubscriptionQueue,+ camera_output_pub: TopicPublicationQueue,+ shutdown_self_flag: multiprocessing.Value,+ camera_shm_dto: SharedMemoryRingBufferDTO,+ ) -> None:+ import cv2+ from skellytracker.trackers.charuco_tracker.charuco_detector import CharucoDetector+ from skellytracker.trackers.mediapipe_tracker import MediapipeDetector++ logger.debug(f"RealtimeCameraNode [{camera_id}] initializing")+ camera_shm = CameraSharedMemoryRingBuffer.recreate(+ dto=camera_shm_dto,+ read_only=False,+ )++ charuco_detector: CharucoDetector | None = None+ mediapipe_detector: MediapipeDetector | None = None++ if config.calibration_detection_enabled:+ charuco_detector = CharucoDetector.create(+ config=config.calibration_config.detector_config,+ )+ if config.mocap_detection_enabled:+ mediapipe_detector = MediapipeDetector.create(+ config=config.mocap_config.detector ,+ )++ frame_rec_array: np.recarray | None = None++ try:+ logger.debug(f"RealtimeCameraNode [{camera_id}] entering main loop")+ while ipc.should_continue and not shutdown_self_flag.value:+ wait_1ms()++ # ---- Handle config updates ----+ while not pipeline_config_sub.empty():+ update_msg: PipelineConfigUpdateMessage = pipeline_config_sub.get()+ new_config = update_msg.pipeline_config+ logger.debug(f"RealtimeCameraNode [{camera_id}] received config update")++ if new_config.calibration_detection_enabled and charuco_detector is None:+ charuco_detector = CharucoDetector.create(+ config=new_config.calibration_config.detector_config,+ )+ elif not new_config.calibration_detection_enabled:+ charuco_detector = None++ if new_config.mocap_detection_enabled and mediapipe_detector is None:+ mediapipe_detector = MediapipeDetector.create(+ config=new_config.mocap_config.detector,+ )+ elif not new_config.mocap_detection_enabled:+ mediapipe_detector = None++ config = new_config++ # ---- Check shared memory validity every iteration ----+ if not camera_shm.valid:+ logger.debug(+ f"RealtimeCameraNode [{camera_id}] "+ f"shared memory invalidated, exiting"+ )+ break++ # ---- Process frames ----+ if process_frame_number_sub.empty():+ continue++ frame_msg: ProcessFrameNumberMessage = process_frame_number_sub.get()+ frame_rec_array = camera_shm.get_data_by_index(+ index=frame_msg.frame_number,+ rec_array=frame_rec_array,+ )++ if frame_rec_array.frame_metadata.camera_config.rotation != -1:+ image = cv2.rotate(+ src=frame_rec_array.image[0],+ rotateCode=frame_rec_array.frame_metadata.camera_config.rotation[0],+ )+ else:+ image = frame_rec_array.image[0]++ actual_frame_number: int = frame_rec_array.frame_metadata.frame_number[0]+ actual_camera_id: CameraIdString = frame_rec_array.frame_metadata.camera_config.camera_id[0]++ if actual_frame_number != frame_msg.frame_number:+ logger.warning(+ f"RealtimeCameraNode [{camera_id}]: requested frame {frame_msg.frame_number} "+ f"but ring buffer contained frame {actual_frame_number} — possible ring buffer overwrite"+ )+ mediapipe_observation = None+ charuco_observation = None+ if mediapipe_detector is not None:+ mediapipe_observation = mediapipe_detector.detect(+ frame_number=actual_frame_number,+ image=image,+ )+ if charuco_detector is not None:+ charuco_observation = charuco_detector.detect(+ frame_number=actual_frame_number,+ image=image,+ )+ if mediapipe_detector is None and charuco_detector is None:+ continue+ camera_output_pub.put(+ CameraNodeOutputMessage(+ camera_id=actual_camera_id,+ frame_number=actual_frame_number,+ charuco_observation=charuco_observation,+ mediapipe_observation = mediapipe_observation+ ),+ )++ except Exception as e:+ logger.exception(f"Exception in RealtimeCameraNode [{camera_id}]: {e}")+ ipc.kill_everything()+ raise+ finally:+ logger.debug(f"RealtimeCameraNode [{camera_id}] exiting")\ No newline at end of filediff --git a/freemocap/core/pipeline/realtime/realtime_pipeline.py b/freemocap/core/pipeline/realtime/realtime_pipeline.pynew file mode 100644index 00000000..07bbfef6--- /dev/null+++ b/freemocap/core/pipeline/realtime/realtime_pipeline.py@@ -0,0 +1,218 @@+"""+RealtimePipeline: a long-lived pipeline attached to a CameraGroup.++Runs indefinitely, processing live camera frames through detection and+(optionally) triangulation. Behavior changes dynamically via config updates+published through the pubsub system.++Calibration or Kinematic reconstructions-specific orchestration (start/stop recording, triggering posthoc+calibration) is NOT here — it belongs in the PipelineManager or route handlers.+"""+import logging+import uuid+from dataclasses import dataclass++from pydantic import BaseModel, ConfigDict+from skellycam.core.camera.config.camera_config import CameraConfigs+from skellycam.core.camera_group.camera_group import CameraGroup+from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry+from skellycam.core.types.type_overloads import CameraIdString, CameraGroupIdString++from freemocap.core.pipeline.pipeline_configs import RealtimePipelineConfig+from freemocap.core.pipeline.pipeline_ipc import PipelineIPC+from freemocap.core.pipeline.realtime.realtime_aggregation_node import RealtimeAggregationNode+from freemocap.core.pipeline.realtime.realtime_camera_node import RealtimeCameraNode+from freemocap.core.viz.frontend_payload import FrontendPayload+from freemocap.core.types.type_overloads import PipelineIdString, TopicSubscriptionQueue, FrameNumberInt+from freemocap.pubsub.pubsub_manager import PubSubTopicManager+from freemocap.pubsub.pubsub_topics import (+ AggregationNodeOutputTopic,+ AggregationNodeOutputMessage,+ PipelineConfigUpdateMessage,+ PipelineConfigUpdateTopic,+)++logger = logging.getLogger(__name__)+++class RealtimePipelineState(BaseModel):+ """Serializable snapshot of pipeline state (for API responses)."""+ model_config = ConfigDict(validate_assignment=True, frozen=True)+ id: PipelineIdString+ camera_group_id: CameraGroupIdString+ alive: bool+ calibration_loaded: bool+++@dataclass+class RealtimePipeline:+ id: PipelineIdString+ camera_group: CameraGroup+ config: RealtimePipelineConfig+ camera_nodes: dict[CameraIdString, RealtimeCameraNode]+ aggregation_node: RealtimeAggregationNode+ aggregation_output_subscription: TopicSubscriptionQueue+ ipc: PipelineIPC+ pubsub: PubSubTopicManager+ started: bool = False++ @property+ def alive(self) -> bool:+ if not self.started:+ return False+ return (+ all(node.is_alive for node in self.camera_nodes.values())+ and self.aggregation_node.is_alive+ )++ @property+ def camera_group_id(self) -> CameraGroupIdString:+ return self.camera_group.id++ @property+ def camera_ids(self) -> list[CameraIdString]:+ return list(self.camera_nodes.keys())++ @property+ def camera_configs(self) -> CameraConfigs:+ return self.camera_group.configs++ @classmethod+ def create(+ cls,+ *,+ camera_group: CameraGroup,+ worker_registry: WorkerRegistry,+ pipeline_config: RealtimePipelineConfig,+ ) -> "RealtimePipeline":+ global_kill_flag = camera_group.ipc.global_kill_flag++ ipc = PipelineIPC.create(+ global_kill_flag=global_kill_flag,+ heartbeat_timestamp=worker_registry.heartbeat_timestamp,+ )+ pubsub = PubSubTopicManager.create(+ global_kill_flag=global_kill_flag,+ )++ camera_nodes = {+ camera_id: RealtimeCameraNode.create(+ camera_id=camera_id,+ worker_registry=worker_registry,+ camera_shm_dto=camera_group.shm.to_dto().camera_shm_dtos[camera_id],+ config=pipeline_config,+ ipc=ipc,+ pubsub=pubsub,+ )+ for camera_id in camera_group.configs.keys()+ }++ aggregation_node = RealtimeAggregationNode.create(+ camera_group_id=camera_group.id,+ worker_registry=worker_registry,+ camera_group_shm_dto=camera_group.shm.to_dto(),+ config=pipeline_config,+ ipc=ipc,+ pubsub=pubsub,+ )++ aggregation_output_subscription = pubsub.get_subscription(+ AggregationNodeOutputTopic,+ )++ return cls(+ id=str(uuid.uuid4())[:6],+ camera_group=camera_group,+ config=pipeline_config,+ camera_nodes=camera_nodes,+ aggregation_node=aggregation_node,+ aggregation_output_subscription=aggregation_output_subscription,+ ipc=ipc,+ pubsub=pubsub,+ )++ def start(self) -> None:+ if self.started:+ raise RuntimeError(f"RealtimePipeline {self.id} already started")+ self.started = True++ logger.info(+ f"Starting RealtimePipeline [{self.id}] for camera group "+ f"[{self.camera_group_id}] with cameras {self.camera_ids}"+ )++ if not self.camera_group.started:+ logger.debug("Starting camera group...")+ self.camera_group.start()++ self.aggregation_node.start()++ for camera_id, node in self.camera_nodes.items():+ node.start()++ logger.info(f"RealtimePipeline [{self.id}] — all workers started")++ def shutdown(self) -> None:+ logger.debug(f"Shutting down RealtimePipeline [{self.id}]")+ self.ipc.shutdown_pipeline()++ # Mark all workers as intentionally terminated BEFORE they die+ # so the WorkerRegistry child monitor doesn't trigger a cascade kill+ for node in self.camera_nodes.values():+ node.worker._intentionally_terminated = True+ self.aggregation_node.worker._intentionally_terminated = True++ self.pubsub.close()+ for node in self.camera_nodes.values():+ if node.is_alive:+ node.shutdown()+ if self.aggregation_node.is_alive:+ self.aggregation_node.shutdown()+ logger.debug(f"RealtimePipeline [{self.id}] shut down")++ def update_config(self, new_config: RealtimePipelineConfig) -> None:+ """Push a config update to all pipeline workers via pubsub."""+ self.config = new_config+ logger.trace(f"Pushing new config to realtime pipeline: {self.id} \n {new_config.model_dump_json(indent=4)}")+ self.pubsub.publish(+ topic_type=PipelineConfigUpdateTopic,+ message=PipelineConfigUpdateMessage(pipeline_config=new_config),+ )++ async def update_camera_configs(self, camera_configs: CameraConfigs) -> CameraConfigs:+ return await self.camera_group.update_camera_settings(+ requested_configs=camera_configs,+ )++ def get_latest_frontend_payload(+ self,+ if_newer_than: FrameNumberInt,+ ) -> tuple[bytes, FrontendPayload | None] | None:+ """+ Drain the aggregation output queue and return the latest payload.+ Returns None if no new data is available.+ """+ if not self.alive:+ if self.camera_group.alive:+ _, _, frames_bytearray = self.camera_group.get_latest_frontend_payload(+ if_newer_than=if_newer_than,+ )+ if frames_bytearray is not None:+ return (frames_bytearray, None)+ return None++ aggregation_output: AggregationNodeOutputMessage | None = None+ while not self.aggregation_output_subscription.empty():+ aggregation_output = self.aggregation_output_subscription.get()++ if aggregation_output is None:+ return None++ frames_bytearray = self.camera_group.get_frontend_payload_by_frame_number(+ frame_number=aggregation_output.frame_number,+ )++ return (+ frames_bytearray,+ FrontendPayload.from_aggregation_output(aggregation_output=aggregation_output),+ )\ No newline at end of filediff --git a/freemocap/core/pipeline/realtime/realtime_pipeline_manager.py b/freemocap/core/pipeline/realtime/realtime_pipeline_manager.pynew file mode 100644index 00000000..1da0d3a8--- /dev/null+++ b/freemocap/core/pipeline/realtime/realtime_pipeline_manager.py@@ -0,0 +1,131 @@+"""+RealtimePipelineManager: lifecycle manager for long-lived realtime pipelines.++Each realtime pipeline is bound to a CameraGroup and runs indefinitely,+processing live frames through detection and (optionally) triangulation.++Responsibilities:+ - Creating/finding pipelines by camera ID set+ - Pushing config updates to running pipelines+ - Streaming aggregated frontend payloads+ - Recording orchestration (start/stop across all pipelines)+ - Orderly shutdown+"""+import logging+import multiprocessing+from dataclasses import dataclass, field++from skellycam.core.camera_group.camera_group import CameraGroup+from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry+from skellycam.core.types.type_overloads import CameraIdString++from freemocap.core.pipeline.pipeline_configs import RealtimePipelineConfig+from freemocap.core.pipeline.realtime.realtime_pipeline import RealtimePipeline+from freemocap.core.types.type_overloads import PipelineIdString, FrameNumberInt+from freemocap.core.viz.frontend_payload import FrontendPayload++logger = logging.getLogger(__name__)+++@dataclass+class RealtimePipelineManager:+ """+ Manages the lifecycle of realtime (camera-bound) pipelines.++ Each pipeline is a singleton per camera ID set — creating a pipeline+ for an already-tracked camera group returns the existing one (with+ an updated config).+ """++ worker_registry: WorkerRegistry+ lock: multiprocessing.Lock = field(default_factory=multiprocessing.Lock)+ pipelines: dict[PipelineIdString, RealtimePipeline] = field(default_factory=dict)++ # ------------------------------------------------------------------+ # Pipeline CRUD+ # ------------------------------------------------------------------++ def create_pipeline(+ self,+ *,+ camera_group: CameraGroup,+ pipeline_config: RealtimePipelineConfig,+ ) -> RealtimePipeline:+ with self.lock:+ # Return existing pipeline for this camera set (with updated config)+ for pipeline in self.pipelines.values():+ if set(pipeline.camera_ids) == set(pipeline_config.camera_ids):+ logger.info(+ f"Found existing RealtimePipeline [{pipeline.id}] "+ f"for camera group [{pipeline.camera_group_id}]"+ )+ pipeline.update_config(new_config=pipeline_config)+ return pipeline++ pipeline = RealtimePipeline.create(+ pipeline_config=pipeline_config,+ camera_group=camera_group,+ worker_registry=self.worker_registry,+ )+ pipeline.start()+ self.pipelines[pipeline.id] = pipeline+ logger.info(+ f"Created RealtimePipeline [{pipeline.id}] "+ f"for camera group [{pipeline.camera_group_id}]"+ )+ return pipeline++ def update_pipeline_config(+ self,+ *,+ pipeline_id: PipelineIdString,+ new_config: RealtimePipelineConfig,+ ) -> RealtimePipeline:+ with self.lock:+ pipeline = self.pipelines.get(pipeline_id)+ if pipeline is None:+ raise KeyError(f"No realtime pipeline with ID '{pipeline_id}'")+ pipeline.update_config(new_config=new_config)+ return pipeline++ def get_pipeline_by_camera_ids(+ self,+ camera_ids: list[CameraIdString],+ ) -> RealtimePipeline | None:+ with self.lock:+ for pipeline in self.pipelines.values():+ if set(pipeline.camera_ids) == set(camera_ids):+ return pipeline+ return None++ # ------------------------------------------------------------------+ # Frontend payload streaming+ # ------------------------------------------------------------------++ def get_latest_frontend_payloads(+ self,+ if_newer_than: FrameNumberInt,+ ) -> dict[PipelineIdString, tuple[bytes | None, FrontendPayload | None]]:+ latest: dict[PipelineIdString, tuple[bytes | None, FrontendPayload | None]] = {}+ with self.lock:+ for pipeline_id, pipeline in self.pipelines.items():+ output = pipeline.get_latest_frontend_payload(if_newer_than=if_newer_than)+ if output is not None:+ latest[pipeline_id] = output+ return latest++ # ------------------------------------------------------------------+ # Lifecycle+ # ------------------------------------------------------------------++ def pause_unpause_all(self) -> None:+ with self.lock:+ for pipeline in self.pipelines.values():+ pipeline.camera_group.pause_unpause()++ def shutdown(self) -> None:+ with self.lock:+ for pipeline in self.pipelines.values():+ pipeline.shutdown()+ self.pipelines.clear()+ logger.info("RealtimePipelineManager: all pipelines shut down")diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_aggregation_node.py b/freemocap/core/pipeline/realtime_pipeline/realtime_aggregation_node.pydeleted file mode 100644index 98fe95b2..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_aggregation_node.py+++ /dev/null@@ -1,176 +0,0 @@-import logging-import multiprocessing-from dataclasses import dataclass--import numpy as np-from pydantic import BaseModel, ConfigDict-from skellycam.core.ipc.shared_memory.camera_group_shared_memory import CameraGroupSharedMemory, \- CameraGroupSharedMemoryDTO-from skellycam.core.types.type_overloads import CameraGroupIdString, CameraIdString, TopicSubscriptionQueue-from skellycam.utilities.wait_functions import wait_1ms--from freemocap.core.pipeline.pipeline_configs import RealtimePipelineConfig-from freemocap.core.pipeline.pipeline_ipc import PipelineIPC-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.charuco_observation_aggregator import \- get_last_successful_calibration_toml_path-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.freemocap_anipose import \- AniposeCameraGroup-from freemocap.core.pipeline.posthoc_pipelines.posthoc_mocap_pipeline.mocap_helpers.triangulate_trajectory_array import \- triangulate_frame_observations-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.shared_view_accumulator import \- SharedViewAccumulator-from freemocap.core.types.type_overloads import Point3d, PipelineIdString-from freemocap.pubsub.pubsub_topics import CameraNodeOutputMessage, PipelineConfigUpdateTopic, ProcessFrameNumberTopic, \- ProcessFrameNumberMessage, AggregationNodeOutputMessage, AggregationNodeOutputTopic, CameraNodeOutputTopic, \- PipelineConfigUpdateMessage, ShouldCalibrateTopic--logger = logging.getLogger(__name__)---class RealtimeAggregationNodeState(BaseModel):- model_config = ConfigDict(- validate_assignment=True,- frozen=True- )- pipeline_id: PipelineIdString- config: RealtimePipelineConfig- alive: bool- last_seen_frame_number: int | None = None- calibration_task_state: object | None = None- mocap_task_state: object = None # TODO - this---@dataclass-class RealtimeAggregationNode:- shutdown_self_flag: multiprocessing.Value- worker: multiprocessing.Process-- @classmethod- def create(cls,- config: RealtimePipelineConfig,- camera_group_id: CameraGroupIdString,- subprocess_registry: list[multiprocessing.Process],- camera_group_shm_dto: CameraGroupSharedMemoryDTO,- ipc: PipelineIPC):- shutdown_self_flag = multiprocessing.Value('b', False)- worker = multiprocessing.Process(target=cls._run,- name=f"CameraGroup-{camera_group_id}-AggregationNode",- kwargs=dict(config=config,- camera_group_id=camera_group_id,- ipc=ipc,- shutdown_self_flag=shutdown_self_flag,- camera_group_shm_dto=camera_group_shm_dto,- camera_node_subscription=ipc.pubsub.topics[- CameraNodeOutputTopic].get_subscription(),- pipeline_config_subscription=ipc.pubsub.topics[- PipelineConfigUpdateTopic].get_subscription(),- should_calibrate_subscription=ipc.pubsub.topics[- ShouldCalibrateTopic].get_subscription(),- ),-- )- subprocess_registry.append(worker)- return cls(shutdown_self_flag=shutdown_self_flag,- worker=worker- )-- @staticmethod- def _run(config: RealtimePipelineConfig,- camera_group_id: CameraGroupIdString,- ipc: PipelineIPC,- shutdown_self_flag: multiprocessing.Value,- camera_group_shm_dto: CameraGroupSharedMemoryDTO,- camera_node_subscription: TopicSubscriptionQueue,- pipeline_config_subscription: TopicSubscriptionQueue,- should_calibrate_subscription: TopicSubscriptionQueue- ):- if multiprocessing.parent_process():- # Configure logging if multiprocessing (i.e. if there is a parent process)- from freemocap.system.logging_configuration.configure_logging import configure_logging- from freemocap import LOG_LEVEL- configure_logging(LOG_LEVEL, ws_queue=ipc.ws_queue)-- logger.debug("AggregationNode - starting main loop")- try:- logger.debug(f"Starting aggregation process for camera group {camera_group_id}")- camera_node_outputs: dict[CameraIdString, CameraNodeOutputMessage | None] = {camera_id: None for camera_id- in- config.camera_configs.keys()}- camera_group_shm = CameraGroupSharedMemory.recreate(shm_dto=camera_group_shm_dto,- read_only=True)- shared_view_accumulator = SharedViewAccumulator.create(camera_ids=config.camera_ids)- latest_requested_frame: int = -1- last_received_frame: int = -1- anipose_camera_group = AniposeCameraGroup.load(str(get_last_successful_calibration_toml_path()))- while ipc.should_continue and not shutdown_self_flag.value:- wait_1ms()-- # Check for updated Pipeline Config- while not pipeline_config_subscription.empty():- pipeline_config_message: PipelineConfigUpdateMessage = pipeline_config_subscription.get()- config = pipeline_config_message.pipeline_config- logger.info(f"AggregationNode for camera group {camera_group_id} received updated config")-- # Check if we should request a new frame to process- if camera_group_shm.latest_multiframe_number > latest_requested_frame and last_received_frame >= latest_requested_frame:- ipc.pubsub.topics[ProcessFrameNumberTopic].publish(- ProcessFrameNumberMessage(frame_number=camera_group_shm.latest_multiframe_number))- latest_requested_frame = camera_group_shm.latest_multiframe_number-- # Check for Camera Node Output- if not camera_node_subscription.empty():- camera_node_output_message: CameraNodeOutputMessage = camera_node_subscription.get()- camera_id = camera_node_output_message.camera_id- if not camera_id in config.camera_configs.keys():- raise ValueError(- f"Camera ID {camera_id} not in camera IDs {list(config.camera_configs.keys())}")- camera_node_outputs[camera_id] = camera_node_output_message-- # Check if ready to process a frame output- if all([isinstance(camera_node_output_message, CameraNodeOutputMessage) for camera_node_output_message- in- camera_node_outputs.values()]):- if not all([camera_node_output_message.frame_number == latest_requested_frame for- camera_node_output_message in camera_node_outputs.values()]):- logger.warning(- f"Frame numbers from tracker results do not match expected ({latest_requested_frame}) - got {[camera_node_output_message.frame_number for camera_node_output_message in camera_node_outputs.values()]}")- last_received_frame = latest_requested_frame-- # shared_view_accumulator.receive_camera_node_output(- # camera_node_output_by_camera=camera_node_outputs,- # multi_frame_number=latest_requested_frame)-- triangulated = triangulate_frame_observations(frame_number=latest_requested_frame,- frame_observations_by_camera={camera_id: camera_node_outputs[camera_id].observation- for camera_id in camera_node_outputs.keys()},- anipose_camera_group=anipose_camera_group,- )-- aggregation_output: AggregationNodeOutputMessage = AggregationNodeOutputMessage(- frame_number=latest_requested_frame,- pipeline_id=ipc.pipeline_id,- camera_group_id=camera_group_id,- pipeline_config=config,- camera_node_outputs=camera_node_outputs,- tracked_points3d=triangulated.to_point_dictionary()- )- ipc.pubsub.topics[AggregationNodeOutputTopic].publish(aggregation_output)- camera_node_outputs = {camera_id: None for camera_id in camera_node_outputs.keys()}--- except Exception as e:- logger.error(f"Exception in AggregationNode for camera group {camera_group_id}: {e}", exc_info=True)- ipc.kill_everything()- raise- finally:- logger.debug(f"Shutting down aggregation process for camera group {camera_group_id}")-- def start(self):- logger.debug(f"Starting AggregationNode worker")- self.worker.start()-- def shutdown(self):- logger.debug(f"Stopping AggregationNode worker")- self.shutdown_self_flag.value = True- self.worker.join()- logger.debug(f"AggregationNode worker stopped")diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_camera_node.py b/freemocap/core/pipeline/realtime_pipeline/realtime_camera_node.pydeleted file mode 100644index 19b5b510..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_camera_node.py+++ /dev/null@@ -1,152 +0,0 @@-import logging-import multiprocessing-import time-from dataclasses import dataclass--import cv2-import numpy as np-from pydantic import BaseModel, ConfigDict-from skellycam.core.ipc.shared_memory.camera_shared_memory_ring_buffer import CameraSharedMemoryRingBuffer-from skellycam.core.ipc.shared_memory.ring_buffer_shared_memory import SharedMemoryRingBufferDTO-from skellycam.core.types.type_overloads import CameraIdString, WorkerType, TopicSubscriptionQueue-from skellycam.utilities.wait_functions import wait_1ms-from skellytracker.trackers.charuco_tracker.charuco_detector import CharucoDetector-from skellytracker.trackers.mediapipe_tracker.mediapipe_detector import MediapipeDetector--from freemocap.core.pipeline.pipeline_configs import RealtimePipelineConfig-from freemocap.core.pipeline.pipeline_ipc import PipelineIPC-from freemocap.core.types.type_overloads import PipelineIdString-from freemocap.pubsub.pubsub_topics import ProcessFrameNumberTopic, PipelineConfigUpdateTopic, CameraNodeOutputTopic, \- PipelineConfigUpdateMessage, ProcessFrameNumberMessage, CameraNodeOutputMessage--logger = logging.getLogger(__name__)---class CameraNodeState(BaseModel):- model_config = ConfigDict(- validate_assignment=True,- frozen=True- )- pipeline_id: PipelineIdString- alive: bool- last_seen_frame_number: int | None = None- calibration_task_state: object | None = None- mocap_task_state: object = None # TODO - this---@dataclass-class RealtimeCameraNode:- camera_id: CameraIdString- shutdown_self_flag: multiprocessing.Value- worker: WorkerType-- @classmethod- def create(cls,- camera_id: CameraIdString,- camera_shm_dto: SharedMemoryRingBufferDTO,- subprocess_registry: list[multiprocessing.Process],- config: RealtimePipelineConfig,- ipc: PipelineIPC):- shutdown_self_flag = multiprocessing.Value('b', False)- worker = multiprocessing.Process(target=cls._run,- name=f"CameraProcessingNode-{camera_id}",- kwargs=dict(camera_id=camera_id,- ipc=ipc,- config=config,- shutdown_self_flag=shutdown_self_flag,- camera_shm_dto=camera_shm_dto,- process_frame_number_subscription=ipc.pubsub.get_subscription(- ProcessFrameNumberTopic),- pipeline_config_subscription=ipc.pubsub.get_subscription(- PipelineConfigUpdateTopic),- ),- )- subprocess_registry.append(worker)- return cls(camera_id=camera_id,- shutdown_self_flag=shutdown_self_flag,- worker=worker- )-- @staticmethod- def _run(camera_id: CameraIdString,- ipc: PipelineIPC,- config: RealtimePipelineConfig,- process_frame_number_subscription: TopicSubscriptionQueue,- pipeline_config_subscription: TopicSubscriptionQueue,- shutdown_self_flag: multiprocessing.Value,- camera_shm_dto: SharedMemoryRingBufferDTO,- ):- if multiprocessing.parent_process():- # Configure logging if multiprocessing (i.e. if there is a parent process)- from freemocap.system.logging_configuration.configure_logging import configure_logging- from freemocap import LOG_LEVEL- configure_logging(LOG_LEVEL, ws_queue=ipc.ws_queue)-- logger.debug(f"Initializing camera processing node for camera {camera_id} - creating shared memory ring buffer")- camera_shm = CameraSharedMemoryRingBuffer.recreate(dto=camera_shm_dto,- read_only=False)- charuco_detector = CharucoDetector.create(config=config.calibration_task_config.detector_config)- mediapipe_detector = MediapipeDetector.create()- try:- logger.trace(f"Starting camera processing node for camera {camera_id}")- frame_rec_array: np.recarray | None = None- while ipc.should_continue and not shutdown_self_flag.value:- wait_1ms()- # Check trackers config updates- while not pipeline_config_subscription.empty():- new_pipeline_config_message: PipelineConfigUpdateMessage = pipeline_config_subscription.get()- logger.debug(f"Received new skelly trackers for camera {camera_id}: {new_pipeline_config_message}")- config = new_pipeline_config_message.pipeline_config-- # Check for new frame to process- if not process_frame_number_subscription.empty():- process_frame_number_message: ProcessFrameNumberMessage = process_frame_number_subscription.get()-- # Process the frame- tik = time.perf_counter_ns()- frame_rec_array = camera_shm.get_data_by_index(index=process_frame_number_message.frame_number,- rec_array=frame_rec_array)- if frame_rec_array.frame_metadata.camera_config.rotation != -1:- rotated_image = cv2.rotate(- src=frame_rec_array.image[0],- rotateCode=frame_rec_array.frame_metadata.camera_config.rotation[0]- )- else:- rotated_image = frame_rec_array.image[0]- observation = mediapipe_detector.detect(- frame_number=frame_rec_array.frame_metadata.frame_number[0],- image=rotated_image, )- # observation = charuco_detector.detect(- # frame_number=frame_rec_array.frame_metadata.frame_number[0],- # image=rotated_image, )-- # tok = time.perf_counter_ns()-- ipc.pubsub.publish(- topic_type=CameraNodeOutputTopic,- message=CameraNodeOutputMessage(- camera_id=frame_rec_array.frame_metadata.camera_config.camera_id[0],- frame_number=frame_rec_array.frame_metadata.frame_number[0],- observation=observation,- ),- )- tok2 = time.perf_counter_ns()- # logger.debug(- # f"Camera {camera_id} processed frame {frame_rec_array.frame_metadata.frame_number[0]} in "- # f"{(tok - tik) / 1e6:.2f} ms, published observation in {(tok2 - tok) / 1e6:.2f} ms")- except Exception as e:- logger.exception(f"Exception in camera node for camera {camera_id}: {e}")- ipc.kill_everything()- raise e- finally:- logger.debug(f"Shutting down camera processing node for camera {camera_id}")-- def start(self):- logger.debug(f"Starting {self.__class__.__name__} for camera {self.camera_id}")- self.worker.start()-- def shutdown(self):- logger.debug(f"Stopping {self.__class__.__name__} for camera {self.camera_id}")- self.shutdown_self_flag.value = True- self.worker.join()- logger.debug(f"{self.__class__.__name__} for camera {self.camera_id} stopped")diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_pipeline.py b/freemocap/core/pipeline/realtime_pipeline/realtime_pipeline.pydeleted file mode 100644index 366fab5a..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_pipeline.py+++ /dev/null@@ -1,192 +0,0 @@-import logging-import multiprocessing-import time-import uuid-from dataclasses import dataclass--from pydantic import BaseModel, ConfigDict-from skellycam.core.camera.config.camera_config import CameraConfigs-from skellycam.core.camera_group.camera_group import CameraGroup-from skellycam.core.recorders.videos.recording_info import RecordingInfo-from skellycam.core.types.type_overloads import CameraIdString, CameraGroupIdString--from freemocap.core.pipeline.realtime_pipeline.realtime_aggregation_node import RealtimeAggregationNode, RealtimeAggregationNodeState-from freemocap.core.pipeline.realtime_pipeline.realtime_camera_node import RealtimeCameraNode, CameraNodeState-from freemocap.core.pipeline.frontend_payload import FrontendPayload-from freemocap.core.pipeline.pipeline_configs import RealtimePipelineConfig-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.posthoc_calibration_pipeline import \- CalibrationpipelineConfig-from freemocap.core.pipeline.pipeline_ipc import PipelineIPC-from freemocap.core.types.type_overloads import PipelineIdString, TopicSubscriptionQueue, FrameNumberInt-from freemocap.pubsub.pubsub_topics import AggregationNodeOutputTopic, AggregationNodeOutputMessage, \- PipelineConfigUpdateMessage, \- PipelineConfigUpdateTopic, ShouldCalibrateMessage, ShouldCalibrateTopic--logger = logging.getLogger(__name__)---class RealtimePipelineState(BaseModel):- """Serializable representation of a processing pipeline state."""- model_config = ConfigDict(- validate_assignment=True,- frozen=True- )- id: PipelineIdString- camera_group_id: CameraGroupIdString- camera_node_states: dict[CameraIdString, CameraNodeState]- aggregation_node_state: RealtimeAggregationNodeState- alive: bool-----@dataclass-class RealtimeProcessingPipeline:- id: PipelineIdString- camera_group: CameraGroup- config: RealtimePipelineConfig- camera_nodes: dict[CameraIdString, RealtimeCameraNode]- aggregation_node: RealtimeAggregationNode- aggregation_node_subscription: TopicSubscriptionQueue- ipc: PipelineIPC- started: bool = False-- @property- def alive(self) -> bool:- return all([camera_node.worker.is_alive() for camera_node in- self.camera_nodes.values()]) and self.aggregation_node.worker.is_alive()-- @property- def camera_group_id(self) -> CameraGroupIdString:- return self.camera_group.id-- @property- def camera_ids(self) -> list[CameraIdString]:- return list(self.camera_nodes.keys())-- @property- def camera_configs(self) -> CameraConfigs:- return self.camera_group.configs-- @classmethod- def from_config(cls,- camera_group: CameraGroup,- heartbeat_timestamp: multiprocessing.Value,- subprocess_registry: list[multiprocessing.Process],- pipeline_config: RealtimePipelineConfig,- ):-- ipc = PipelineIPC.create(global_kill_flag=camera_group.ipc.global_kill_flag,- heartbeat_timestamp=heartbeat_timestamp- )- camera_nodes = {camera_id: RealtimeCameraNode.create(camera_id=camera_id,- subprocess_registry=subprocess_registry,- camera_shm_dto=camera_group.shm.to_dto().camera_shm_dtos[camera_id],- config=pipeline_config,- ipc=ipc)- for camera_id, config in camera_group.configs.items()}- aggregation_node = RealtimeAggregationNode.create(camera_group_id=camera_group.id,- subprocess_registry=subprocess_registry,- camera_group_shm_dto=camera_group.shm.to_dto(),- config=pipeline_config,- ipc=ipc,- )-- return cls(camera_nodes=camera_nodes,- aggregation_node=aggregation_node,- ipc=ipc,- config=pipeline_config,- aggregation_node_subscription=ipc.pubsub.topics[- AggregationNodeOutputTopic].get_subscription(),- camera_group=camera_group,- id=str(uuid.uuid4())[:6],- )-- def start(self) -> None:- self.started = True- logger.debug(- f"Starting Pipeline (id:{self.id} with camera group (id:{self.camera_group_id} for camera ids: {list(self.camera_nodes.keys())}...")- if not self.camera_group.started:- try:- logger.debug("Starting camera group...")- self.camera_group.start()- except Exception as e:- logger.error(f"Failed to start camera group: {type(e).__name__} - {e}")- logger.exception(e)- raise-- try:- logger.debug("Starting aggregation node...")- self.aggregation_node.start()- logger.debug(f"Aggregation node worker started: alive={self.aggregation_node.worker.is_alive()}")- except Exception as e:- logger.error(f"Failed to start aggregation node: {type(e).__name__} - {e}")- logger.exception(e)- raise-- for camera_id, camera_node in self.camera_nodes.items():- try:- logger.debug(f"Starting camera node {camera_id}...")- camera_node.start()- logger.debug(f"Camera node {camera_id} worker started: alive={camera_node.worker.is_alive()}")- except Exception as e:- logger.error(f"Failed to start camera node {camera_id}: {type(e).__name__} - {e}")- logger.exception(e)- raise-- logger.info(f"All pipeline workers started successfully")-- def shutdown(self):- logger.debug(f"Shutting down {self.__class__.__name__}...")-- self.ipc.shutdown_pipeline()- for camera_id, camera_node in self.camera_nodes.items():- camera_node.shutdown()- self.aggregation_node.shutdown()-- async def update_camera_configs(self, camera_configs: CameraConfigs) -> CameraConfigs:- return await self.camera_group.update_camera_settings(requested_configs=camera_configs)-- def get_latest_frontend_payload(self, if_newer_than: FrameNumberInt) -> tuple[bytes, FrontendPayload | None] | None:- if not self.alive:- if self.camera_group.alive:- _, _, frames_bytearray = self.camera_group.get_latest_frontend_payload(if_newer_than=if_newer_than)- if frames_bytearray is not None:- return (frames_bytearray,- None)- return None- aggregation_output: AggregationNodeOutputMessage | None = None- while not self.aggregation_node_subscription.empty():- aggregation_output = self.aggregation_node_subscription.get()- if aggregation_output is None:- return None- frames_bytearray = self.camera_group.get_frontend_payload_by_frame_number(- frame_number=aggregation_output.frame_number,- )-- return (frames_bytearray,- FrontendPayload.from_aggregation_output(aggregation_output=aggregation_output))-- def update_pipeline_config(self, new_config: RealtimePipelineConfig) -> None:- self.config = new_config- self.ipc.pubsub.topics[PipelineConfigUpdateTopic].publish(- PipelineConfigUpdateMessage(pipeline_config=self.config)- )-- async def start_calibration_recording(self, recording_info: RecordingInfo, config: CalibrationpipelineConfig):- # TODO - I don't love this method of getting the config and path here, wanna fix it later- config.calibration_recording_folder = recording_info.full_recording_path- logger.info(f"Starting calibration recording: {recording_info.full_recording_path} with config: {config.model_dump_json(indent=2)}")- self.config.calibration_task_config = config- self.ipc.pubsub.topics[PipelineConfigUpdateTopic].publish(- PipelineConfigUpdateMessage(pipeline_config=self.config))- await self.camera_group.start_recording(recording_info=recording_info)- logger.info("Calibration recording started.")-- async def stop_calibration_recording(self):- logger.info("Stopping calibration recording...")- # TODO - I don't love this method of getting the config and path here, wanna fix it later- await self.camera_group.stop_recording()- time.sleep(1) # give it a sec to wrap up- logger.info(f"Calibration recording stopped - sending calibration start message - config: {self.config.calibration_task_config.model_dump_json(indent=2)}")- self.ipc.pubsub.topics[ShouldCalibrateTopic].publish(ShouldCalibrateMessage())diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_pipeline_manager.py b/freemocap/core/pipeline/realtime_pipeline/realtime_pipeline_manager.pydeleted file mode 100644index 7cc4fb78..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_pipeline_manager.py+++ /dev/null@@ -1,127 +0,0 @@-import logging-import multiprocessing-from copy import deepcopy-from dataclasses import dataclass, field--from skellycam.core.recorders.videos.recording_info import RecordingInfo-from skellycam.core.types.type_overloads import CameraIdString-from skellycam.core.camera_group.camera_group import CameraGroup--from freemocap.core.pipeline.frontend_payload import FrontendPayload-from freemocap.core.pipeline.pipeline_configs import RealtimePipelineConfig-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.posthoc_calibration_pipeline import \- CalibrationpipelineConfig-from freemocap.core.pipeline.realtime_pipeline.realtime_pipeline import RealtimeProcessingPipeline-from freemocap.core.types.type_overloads import PipelineIdString, FrameNumberInt-from fastapi import FastAPI-logger = logging.getLogger(__name__)---@dataclass-class RealtimePipelineManager:- global_kill_flag: multiprocessing.Value- heartbeat_timestamp: multiprocessing.Value- subprocess_registry: list[multiprocessing.Process]- lock: multiprocessing.Lock = field(default_factory=multiprocessing.Lock)- realtime_pipelines: dict[PipelineIdString, RealtimeProcessingPipeline] = field(default_factory=dict)-- @classmethod- def from_fastapi_app(cls, fastapi_app:FastAPI) -> 'RealtimePipelineManager':- return cls(global_kill_flag=fastapi_app.state.global_kill_flag,- heartbeat_timestamp=fastapi_app.state.heartbeat_timestamp,- subprocess_registry=fastapi_app.state.subprocess_registry)-- async def create_realtime_pipeline(self,- camera_group: CameraGroup,- pipeline_config: RealtimePipelineConfig) -> RealtimeProcessingPipeline:- with self.lock:- # get existing pipeline for the provided camera configs, if it exists- for pipeline in self.realtime_pipelines.values():- if set(pipeline.camera_ids) == set(pipeline_config.camera_ids):- logger.info(- f"Found existing pipeline with ID: {pipeline.id} for camera group ID: {pipeline.camera_group_id}")- await pipeline.update_camera_configs(camera_configs=pipeline_config.camera_configs)- return pipeline- pipeline = RealtimeProcessingPipeline.from_config(pipeline_config=pipeline_config,- heartbeat_timestamp=self.heartbeat_timestamp,- camera_group=camera_group,- subprocess_registry=self.subprocess_registry)- pipeline.start()- self.realtime_pipelines[pipeline.id] = pipeline- logger.info(f"Created pipeline with ID: {pipeline.id} for camera group ID: {pipeline.camera_group_id}")- return pipeline-- async def update_realtime_pipeline(self,- pipeline_config: RealtimePipelineConfig) -> RealtimeProcessingPipeline:- with self.lock:- # get existing pipeline for the provided camera configs, if it exists- for pipeline in self.realtime_pipelines.values():- if set(pipeline.camera_ids) == set(pipeline_config.camera_ids):- logger.info(- f"Found existing pipeline with ID: {pipeline.id} for camera group ID: {pipeline.camera_group_id}")- await pipeline.update_camera_configs(camera_configs=pipeline_config.camera_configs)- return pipeline- raise RuntimeError("No existing pipeline found for the provided camera configs.")-- def close_all_realtime_pipelines(self):- with self.lock:- for pipeline in self.realtime_pipelines.values():- pipeline.shutdown()- self.realtime_pipelines.clear()- logger.info("All pipelines closed successfully")-- def get_latest_frontend_payloads(self, if_newer_than: FrameNumberInt) -> dict[- PipelineIdString, tuple[bytes | None, FrontendPayload | None]]:- latest_outputs = {}- with self.lock:- for pipeline_id, pipeline in self.realtime_pipelines.items():- output = pipeline.get_latest_frontend_payload(if_newer_than=if_newer_than)- if not output is None:- latest_outputs[pipeline_id] = output- return latest_outputs-- def pause_unpause_pipelines(self):- with self.lock:- for pipeline in self.realtime_pipelines.values():- pipeline.camera_group.pause_unpause()-- async def start_recording_all(self, recording_info: RecordingInfo):- with self.lock:- for pipeline in self.realtime_pipelines.values():- await pipeline.camera_group.start_recording(recording_info=recording_info)-- async def stop_recording_all(self) -> list[RecordingInfo]:- with self.lock:- recording_infos= []- for pipeline in self.realtime_pipelines.values():- recording_infos.append( await pipeline.camera_group.stop_recording())- return recording_infos-- def update_calibration_task_config(self, calibration_task_config: CalibrationpipelineConfig):- with self.lock:- for pipeline in self.realtime_pipelines.values():- new_config = deepcopy(pipeline.config)- new_config.calibration_task_config = calibration_task_config- pipeline.update_pipeline_config(new_config=new_config)-- def get_pipeline_by_camera_ids(self, camera_ids: list[CameraIdString]) -> RealtimeProcessingPipeline | None:- with self.lock:- for pipeline in self.realtime_pipelines.values():- if set(pipeline.camera_ids) == set(camera_ids):- return pipeline- return None-- async def create_or_update_realtime_calibration_pipeline(self, calibration_task_config: CalibrationpipelineConfig) -> RealtimeProcessingPipeline:- with self.lock:- # TODO - update specific pipelines by id, for now update all pipelines- for pipeline in self.realtime_pipelines.values():- new_config = deepcopy(pipeline.config)- new_config.calibration_task_config = calibration_task_config- pipeline.update_pipeline_config(new_config=new_config)- return pipeline- raise RuntimeError("No existing pipeline found for the provided camera configs.")-- async def stop_calibration_recording(self, calibration_task_config: CalibrationpipelineConfig):- pass--diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/anipose_flavored_stuff/anipose_calibration_optimizer.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/anipose_flavored_stuff/anipose_calibration_optimizer.pydeleted file mode 100644index 94859f21..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/anipose_flavored_stuff/anipose_calibration_optimizer.py+++ /dev/null@@ -1,626 +0,0 @@-import logging--import cv2-import numpy as np-from freemocap.zzold.core_processes.capture_volume_calibration.anipose_camera_calibration.run_anipose_calibration_algorithm import \- anipose_triangulate_simple, remap_ids-from numba import jit-from pydantic import BaseModel-from scipy import optimize-from scipy.linalg import inv as inverse-from scipy.sparse import dok_matrix-from tqdm import trange--from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.anipose_flavored_stuff.calibration_utilities import \- calculate_error_bounds, transform_points, construct_camera_extrinsics_matrix, \- get_rotation_and_translation_vector_from_extrinsics_matrix, get_error_dict-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.calibration_numpy_types import ImagePoints2D, \- ObjectPoints3D, ExtrinsicsParameters, IntrinsicsParameters, ReprojectionErrorByPoint, ImagePoints2DByCamera, \- PointIds, \- RotationVectorsByCamera, TranslationVectorsByCamera-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.single_camera_calibrator import \- SingleCameraCalibrator--logger = logging.getLogger(__name__)---class SingleCameraCalibrationHelper(BaseModel):- calibrator: SingleCameraCalibrator-- @property- def pixel_points2d(self) -> ImagePoints2D:- return self.calibrator.image_points_views-- def get_optimizable_parameters(self) -> tuple[ExtrinsicsParameters, IntrinsicsParameters]:- """- Grabs the parameters that will be optimized and organizes them in a numpy array- """- extrinsics_parameters = np.zeros(6, dtype="float64")- extrinsics_parameters[0:3] = self.rotation_vector- extrinsics_parameters[3:6] = self.translation_vector-- intrinsics_parameters = np.zeros(3, dtype="float64")- extrinsics_parameters[0] = self.focal_length- extrinsics_parameters[1] = self.distortion_coefficients[0]- extrinsics_parameters[2] = self.distortion_coefficients[1]- return extrinsics_parameters, intrinsics_parameters-- def set_optimized_parameters(self,- extrinsics_parameters: ExtrinsicsParameters,- intrinsics_parameters: IntrinsicsParameters):-- self.rotation_vector = extrinsics_parameters[0:3]- self.translation_vector = extrinsics_parameters[3:6]-- self.focal_length = intrinsics_parameters[0]-- distortion_coefficients = np.zeros(5)- distortion_coefficients[0] = intrinsics_parameters[1]- distortion_coefficients[1] = intrinsics_parameters[2]- self.distortion_coefficients = distortion_coefficients-- def undistort_points(self, points2d: ImagePoints2D) -> ImagePoints2D:- """- Undistorts 2D points using the camera's intrinsic parameters and distortion coefficients.-- This function adjusts the provided 2D points to account for lens distortion, returning- points that are mapped as they would appear in an ideal pinhole camera model. The process- ensures that the ray passing from the nodal point of the camera lens through the- undistorted 2D point intersects the corresponding 3D point in space accurately.-- :param points2d: A NumPy array of shape (N, 2) or (N, 1, 2) representing the 2D points- to be undistorted. These are typically the distorted pixel coordinates- captured by the camera.- :return: A NumPy array of the same shape as `points2d` containing the undistorted 2D points.- """- shape = points2d.shape- points2d = points2d.reshape(-1, 1, 2)- undistorted_points2d = cv2.undistortPoints(points2d,- self.camera_matrix.astype("float64"),- self.distortion_coefficients.astype("float64"))- return undistorted_points2d.reshape(shape)-- def project_3d_to_2d(self, points3d: ObjectPoints3D) -> ImagePoints2D:- if not points3d.shape[-1] == 3:- raise ValueError("points3d must have shape (N, 3)")- points3d = points3d.reshape(-1, 1, 3)- projected_2d_points, _ = cv2.projectPoints(- points3d,- self.rotation_vector,- self.translation_vector,- self.camera_matrix.astype("float64"),- self.distortion_coefficients.astype("float64"),- )- if projected_2d_points.shape != (points3d.shape[0], 1, 2):- raise ValueError(f"projected_2d_points has incorrect shape: {projected_2d_points.shape}")-- return projected_2d_points-- def single_camera_reprojection_error(self, points3d: ObjectPoints3D,- points2d: ImagePoints2D) -> ReprojectionErrorByPoint:- projected_points3d = self.project_3d_to_2d(points3d)- projecting_3d_points_onto_2d_image_plane = projected_points3d.reshape(points2d.shape)- return points2d - projecting_3d_points_onto_2d_image_plane---class MultiCameraCalibrationInputData(BaseModel):- pixel_points2d: ImagePoints2DByCamera- object_points3d: ObjectPoints3D- points_ids: PointIds- rotation_vectors: RotationVectorsByCamera- translation_vectors: TranslationVectorsByCamera-- @classmethod- def from_single_camera_helpers(cls, camera_helpers: dict[CameraId, SingleCameraCalibrationHelper]):- pixel_points2d = [camera_helper.calibrator.image_points_views for camera_helper in camera_helpers.values()]- object_points3d = [camera_helper.calibrator.object_points_views for camera_helper in camera_helpers.values()]- rotation_vectors = np.array(- [camera_helper.calibrator.rotation_vector for camera_helper in camera_helpers.values()])- translation_vectors = np.array(- [camera_helper.calibrator.translation_vector for camera_helper in camera_helpers.values()])- return cls(pixel_points2d=pixel_points2d,- object_points3d=object_points3d,- points_ids=points_ids,- rotation_vectors=rotation_vectors,- translation_vectors=translation_vectors)---class MultiCameraCalibrationOptimizer(BaseModel):- camera_helpers: dict[CameraId, SingleCameraCalibrationHelper]-- max_iterations: int = 10- starting_error_threshold: float = 15.0- ending_error_threshold: float = 1.0- max_number_function_evals: int = 200- function_tolerance: float = 1e-4- number_of_samples_per_iteration: int = 100- number_of_samples_full: int = 1000- error_threshold: float = 0.3-- @classmethod- def from_single_camera_calibrators(cls, single_camera_calibrators: dict[CameraId, SingleCameraCalibrator]):- camera_helpers = {camera_id: SingleCameraCalibrationHelper(calibrator=calibrator)- for camera_id, calibrator in single_camera_calibrators.items()}- return cls(camera_helpers=camera_helpers)-- def run_iterative_bundle_adjustment(self) -> float:- """- Performs iterative bundle adjustment to refine camera parameters.- based on Anipose's iterative bundle adjustment method. (`bundle_adjust_iter`)- """-- # Perform bundle adjustment- self.bundle_adjust_points2d(- mc_calibration_input_data=MultiCameraCalibrationInputData.from_single_camera_helpers(self.camera_helpers),- loss="linear",- function_tolerance=self.function_tolerance,- maximum_number_function_evals=self.max_number_function_evals,- )-- # Initialize- error_list = []-- original_error = self.get_mean_reprojection_error(original_points2d, median=True)- logger.info(- f"Starting iterative bundle adjustment..."- f"\n\tNumber of cameras: {len(self.camera_calibration_estimates)}"- f"\n\tNumber of points: {original_points2d.shape[1]}"- f"\n\tOriginal error: {original_error:.2f}")-- # Calculate dynamic error thresholds for each iteration- error_thresholds = np.exp(- np.linspace(np.log(self.starting_error_threshold), np.log(self.ending_error_threshold),- num=self.max_iterations))-- logger.debug(f"Error thresholds we will use for each bundle adjustment iteration: {error_thresholds}")-- # Iterative bundle adjustment- dynamic_error_threshold = self.starting_error_threshold- for iteration in range(self.max_iterations):- resampled_calibration_input_data = original_calibration_input_data-- # Triangulate 3D points from resampled 2D points- triangulated_points3d = self.triangulate(resampled_calibration_input_data.pixel_points2d)-- # Calculate reprojection errors- errors_full = self.calculate_reprojection_error(- triangulated_points3d, resampled_calibration_input_data.pixel_points2d, mean=False- )- normalized_errors = self.calculate_reprojection_error(- triangulated_points3d, resampled_calibration_input_data.pixel_points2d, mean=True- )-- # Compute error statistics- error_dict = get_error_dict(errors_full)- max_error, min_error = calculate_error_bounds(error_dict)- dynamic_error_threshold = max(min(max_error, error_thresholds[iteration]), min_error)-- # Determine good points based on current threshold- good_points_mask = normalized_errors < dynamic_error_threshold- good_points_indicies = np.where(good_points_mask)[0]- # Update error list and check for convergence- current_error = np.median(normalized_errors)- error_list.append(current_error)- if current_error < self.error_threshold:- logger.debug(f"Converged after {iteration + 1} iterations")- break-- logger.debug(f"Bundle Adjust Iteration {iteration + 1} -"- f"\n\tError: {current_error:.2f}, "- f"\n\tThreshold: {dynamic_error_threshold:.1f}, "- f"\n\tProportion of points that meet this threshold: {np.mean(good_points_mask):.3f}")- logger.debug("Error scores from prior iterations", error_list)-- # Perform bundle adjustment- self.bundle_adjust_points2d(- resampled_calibration_input_data.resample_indicies(list(good_points_indicies)),- loss="linear",- function_tolerance=self.function_tolerance,- maximum_number_function_evals=self.max_number_function_evals,- )-- # Final adjustments and error calculation- final_calibration_input_data = resample_points_based_on_shared_views(- calibration_input_data=original_calibration_input_data,- number_of_samples_to_return=self.number_of_samples_full- )- self.final_adjustments(calibration_input_data=final_calibration_input_data,- error_threshold=dynamic_error_threshold- )-- final_error = self.get_mean_reprojection_error(final_calibration_input_data.pixel_points2d, median=True)- print("Final error: ", final_error)-- return float(final_error)-- # @jit(parallel=True, forceobj=True)- def calculate_reprojection_error(self,- points_3d: np.ndarray,- points_2d: np.ndarray,- mean: bool = False):- """Given an Nx3 array of 3D points and an CxNx2 array of 2D points,- where N is the number of points and C is the number of cameras,- this returns an CxNx2 array of errors.- Optionally mean=True, this averages the errors and returns array of length N of errors"""- if not points_3d.shape[0] == points_2d.shape[1]:- raise ValueError(- f"Invalid points shape, first dim of 3D points should be equal to"- f" number of points in 2D points ({points_2d.shape[1]}), but shape is {points_3d.shape}"- )- if not points_2d.shape[0] == len(self.camera_calibration_estimates):- raise ValueError(- f"Invalid points shape, first dim of 2D points should be equal to"- f" number of cameras ({len(self.camera_calibration_estimates)}), but shape is {points_2d.shape}"- )- if not points_3d.shape[1] == 3:- raise ValueError(- f"Invalid points shape, second dim of 3D points should be 3, but shape is {points_3d.shape}")-- if not points_2d.shape[2] == 2:- raise ValueError(- f"Invalid points shape, third dim of 2D points should be 2, but shape is {points_2d.shape}")-- one_point = False- if len(points_3d.shape) == 1 and len(points_2d.shape) == 2:- points_3d = points_3d.reshape(1, 3)- points_2d = points_2d.reshape(-1, 1, 2)- one_point = True-- n_cams, n_points, _ = points_2d.shape- if not points_3d.shape == (n_points, 3,):- raise ValueError("shapes of 2D and 3D points are not consistent: " "2D={}, 3D={}".format(points_2d.shape,- points_3d.shape))-- errors = np.empty((n_cams, n_points, 2))-- for camera_number, cam in enumerate(self.camera_calibration_estimates.values()):- errors[camera_number] = cam.single_camera_reprojection_error(points_3d, points_2d[camera_number])-- if mean:- errors_norm = np.linalg.norm(errors, axis=2)- good = ~np.isnan(errors_norm)- errors_norm[~good] = 0- denom = np.sum(good, axis=0).astype("float64")- denom[denom < 1.5] = np.nan- errors = np.sum(errors_norm, axis=0) / denom-- if one_point:- if mean:- errors = float(errors[0])- else:- errors = errors.reshape(-1, 2)-- return errors-- def project_3d_to_2d(self, points3d: np.ndarray):- """Given an Nx3 array of points, this returns an CxNx2 array of 2D points,- where C is the number of cameras"""- points3d = points3d.reshape(-1, 1, 3)- n_points = points3d.shape[0]- n_cams = len(self.camera_calibration_estimates)-- projected_points2d = np.empty((n_cams, n_points, 2), dtype="float64")- for camera_number, camera in enumerate(self.camera_calibration_estimates.values()):- projected_points2d[camera_number] = camera.project_3d_to_2d(points3d).reshape(n_points, 2)-- # check shape- assert projected_points2d.shape == (n_cams, n_points,- 2), f"Invalid projected_points2d shape, should be {n_cams, n_points, 2}, but shape is {projected_points2d.shape}"-- return projected_points2d-- def triangulate(self, points2d, undistort=True, progress=False):- """Given an CxNx2 array, this returns an Nx3 array of points,- where N is the number of points and C is the number of cameras"""-- assert points2d.shape[0] == len(- self.camera_calibration_estimates- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.camera_calibration_estimates), points2d.shape- )-- one_point = False- if len(points2d.shape) == 2:- points2d = points2d.reshape(-1, 1, 2)- one_point = True-- if undistort:- new_points = np.empty(points2d.shape)- for camera_number, camera in enumerate(self.camera_calibration_estimates.values()):- # must copy in order to satisfy opencv underneath- sub = np.copy(points2d[camera_number])- new_points[camera_number] = camera.undistort_points(sub)- points2d = new_points-- n_cams, n_points, _ = points2d.shape-- triangulated_points3d = np.empty((n_points, 3))- triangulated_points3d[:] = np.nan-- camera_matricies = np.array([camera.extrinsics_matrix for camera in self.camera_calibration_estimates.values()])-- if progress:- points_iterator = trange(n_points, ncols=70)- else:- points_iterator = range(n_points)-- for point_index in points_iterator:- point_xy = points2d[:, point_index, :]- point_xy_no_nans = ~np.isnan(point_xy[:, 0])- if np.sum(point_xy_no_nans) >= 2:- triangulated_points3d[point_index] = anipose_triangulate_simple(point_xy[point_xy_no_nans],- camera_matricies[point_xy_no_nans])-- if one_point:- triangulated_points3d = triangulated_points3d[0]-- return triangulated_points3d-- def final_adjustments(self,- calibration_input_data: MultiCameraCalibrationInputData,- error_threshold: float) -> None:- """Perform final adjustments and bundle adjustment with a potentially updated threshold. """- triangulated_points3d = self.triangulate(calibration_input_data.pixel_points2d)- errors_full = self.calculate_reprojection_error(- triangulated_points3d, calibration_input_data.pixel_points2d, mean=False- )- normalized_errors = self.calculate_reprojection_error(- triangulated_points3d, calibration_input_data.pixel_points2d, mean=True- )- error_dict = get_error_dict(errors_full)-- logger.debug("Error dictionary after final adjustments", error_dict)-- max_error, min_error = calculate_error_bounds(error_dict)- dynamic_error_threshold = max(max(max_error, error_threshold), min_error)- good_points_mask = normalized_errors < dynamic_error_threshold- good_points_indicies = np.where(good_points_mask)[0]- self.bundle_adjust_points2d(- calibration_input_data.resample_indicies(list(good_points_indicies)),- loss="linear",- function_tolerance=self.function_tolerance,- maximum_number_function_evals=self.max_number_function_evals,- )-- def bundle_adjust_points2d(- self,- mc_calibration_input_data: MultiCameraCalibrationInputData,- loss: str = "linear",- threshold: float = 50.0,- function_tolerance: float = 1e-4,- maximum_number_function_evals: int = 1000,- start_params: np.ndarray | None = None,-- ) -> float:- """Perform bundle adjustment to fine-tune camera parameters"""- points2d = mc_calibration_input_data.pixel_points2d- # Validate input shapes- if not points2d.ndim == 3 and points2d.shape[2] == 2:- raise ValueError("points2d must be a CxNx2 array")- if not points2d.shape[0] == len(self.camera_calibration_estimates):- raise ValueError(- f"Invalid points shape, expected first dimension to be equal to "- f"number of cameras ({len(self.camera_calibration_estimates)}), but got shape {points2d.shape}"- )-- # Initialize parameters for bundle adjustment- initial_params, num_camera_params = self._initalize_bundle_adjust_parameters(mc_calibration_input_data)-- # Override initial parameters if start_params are provided- if start_params is not None:- initial_params = start_params- num_camera_params = len(self.camera_calibration_estimates[0].get_optimizable_parameters())-- # Define error function and sparsity pattern for optimization-- jac_sparsity = self._calculate_bundle_adjustment_jacobian_sparsity(mc_calibration_input_data, num_camera_params)-- # Set up optimization options- optimization_result = optimize.least_squares(- fun=self._bundle_adjust_error_function,- x0=initial_params,- jac_sparsity=jac_sparsity,- f_scale=threshold,- x_scale="jac",- loss=loss,- ftol=function_tolerance,- method="trf",- tr_solver="lsmr",- verbose=2,- max_nfev=maximum_number_function_evals,- args=(points2d, num_camera_params),- )-- # Update camera parameters with optimized results- optimized_params = optimization_result.x- for i, camera in enumerate(self.camera_calibration_estimates.values()):- start_idx = i * num_camera_params- end_idx = (i + 1) * num_camera_params- camera.set_optimized_parameters(optimized_params[start_idx:end_idx])-- # Calculate and return the mean reprojection error- mean_error = self.get_mean_reprojection_error(points2d)- return float(mean_error)-- @jit(parallel=True, forceobj=True)- def _bundle_adjust_error_function(self,- optimizable_parameters: np.ndarray,- calibration_input_data: MultiCameraCalibrationInputData,- number_of_camera_parameters: int,- ):- """Error function for bundle adjustment"""- points2d = calibration_input_data.pixel_points2d- good = ~np.isnan(points2d)- n_cams = len(self.camera_calibration_estimates)-- for i, cam in enumerate(self.camera_calibration_estimates.values()):- cam = self.camera_calibration_estimates[i]- a = i * number_of_camera_parameters- b = (i + 1) * number_of_camera_parameters- cam.set_optimized_parameters(optimizable_parameters[a:b])-- n_cams = len(self.camera_calibration_estimates)- sub = number_of_camera_parameters * n_cams- n3d = points2d.shape[1] * 3- p3ds_test = optimizable_parameters[sub: sub + n3d].reshape(-1, 3)- errors = self.calculate_reprojection_error(p3ds_test, points2d)- errors_reproj = errors[good]-- ids = remap_ids(calibration_input_data.ids)- object_points3d = calibration_input_data.object_points3d- min_scale = np.min(object_points3d[object_points3d > 0])- n_boards = int(np.max(ids)) + 1- a = sub + n3d- rotation_vectors = optimizable_parameters[a: a + n_boards * 3].reshape(-1, 3)- translation_vectors = optimizable_parameters[a + n_boards * 3: a + n_boards * 6].reshape(-1, 3)- expected = transform_points(object_points3d, rotation_vectors[ids], translation_vectors[ids])- errors_obj = 2 * (p3ds_test - expected).ravel() / min_scale-- return np.hstack([errors_reproj, errors_obj])-- def _calculate_bundle_adjustment_jacobian_sparsity(self,- calibration_input_data: MultiCameraCalibrationInputData,- number_of_camear_parameters: int) -> dok_matrix:- """Given an CxNx2 array of 2D points,- where N is the number of points and C is the number of cameras,- compute the sparsity structure of the jacobian for bundle adjustment"""-- points2d = calibration_input_data.pixel_points2d- point_indices = np.zeros(points2d.shape, dtype="int32")- cam_indices = np.zeros(points2d.shape, dtype="int32")-- for i in range(points2d.shape[1]):- point_indices[:, i] = i-- for j in range(points2d.shape[0]):- cam_indices[j] = j-- good = ~np.isnan(points2d)-- def remap_ids(ids: np.ndarray | list[int]) -> np.ndarray:- """- Remap the unique identifiers in the input array to a consecutive range starting from zero.-- :param ids: An array-like structure containing the original identifiers.- :return: A NumPy array with the identifiers remapped to a consecutive range.- """- ids_array = np.asarray(ids)- unique_ids, remapped_ids = np.unique(ids_array, return_inverse=True)- return remapped_ids-- ids = remap_ids(calibration_input_data.ids)-- n_boards = int(np.max(ids)) + 1- total_board_params = n_boards * (3 + 3) # rotation_vectors + translation_vectors-- n_cams = points2d.shape[0]- n_points = points2d.shape[1]- total_params_reproj = n_cams * number_of_camear_parameters + n_points * 3- n_params = total_params_reproj + total_board_params-- n_good_values = np.sum(good)-- n_errors = n_good_values + n_points * 3-- A_sparse = dok_matrix((n_errors, n_params), dtype="int16")-- cam_indices_good = cam_indices[good]- point_indices_good = point_indices[good]-- # -- reprojection error --- ix = np.arange(n_good_values)-- ## update camera params based on point error- for i in range(number_of_camear_parameters):- A_sparse[ix, cam_indices_good * number_of_camear_parameters + i] = 1-- ## update point position based on point error- for i in range(3):- A_sparse[ix, n_cams * number_of_camear_parameters + point_indices_good * 3 + i] = 1-- # -- match for the object points---- point_ix = np.arange(n_points)-- ## update all the camera parameters- # A_sparse[n_good_values:n_good_values+n_points*3,- # 0:n_cams*n_cam_params] = 1-- ## update board rotation and translation based on error from expected- for i in range(3):- for j in range(3):- A_sparse[- n_good_values + point_ix * 3 + i,- total_params_reproj + ids * 3 + j,- ] = 1- A_sparse[- n_good_values + point_ix * 3 + i,- total_params_reproj + n_boards * 3 + ids * 3 + j,- ] = 1-- ## update point position based on error from expected- for i in range(3):- A_sparse[- n_good_values + point_ix * 3 + i,- n_cams * number_of_camear_parameters + point_ix * 3 + i,- ] = 1-- return A_sparse-- def _initalize_bundle_adjust_parameters(self, calibration_input_data: MultiCameraCalibrationInputData):- """Given an CxNx2 array of 2D points,- where N is the number of points and C is the number of cameras,- initializes the parameters for bundle adjustment"""-- cam_params = np.hstack([cam.get_optimizable_parameters() for cam in self.camera_calibration_estimates.values()])- n_cam_params = len(cam_params) // len(self.camera_calibration_estimates)-- total_cam_params = len(cam_params)-- n_cams, n_points, _ = calibration_input_data.pixel_points2d.shape- assert n_cams == len(self.camera_calibration_estimates), (- "number of cameras in CameraGroup does not " "match number of cameras in 2D points given"- )-- points3d = self.triangulate(calibration_input_data.pixel_points2d)-- ids = remap_ids(calibration_input_data.ids)- n_boards = int(np.max(ids[~np.isnan(ids)])) + 1- total_board_params = n_boards * (3 + 3) # rotation_vectors + translation_vectors-- # initialize to 0- rotation_vectors = np.zeros((n_boards, 3), dtype="float64")- translation_vectors = np.zeros((n_boards, 3), dtype="float64")-- rotation_vectors_all = calibration_input_data.rotation_vectors- translation_vectors_all = calibration_input_data.translation_vectors- for board_num in range(n_boards):- point_id = np.where(ids == board_num)[0][0]- cam_ids_possible = np.where(~np.isnan(calibration_input_data.pixel_points2d[:, point_id, 0]))[0]- cam_id = np.random.choice(cam_ids_possible)- camera_extrinsics_matrix = self.camera_calibration_estimates[cam_id].extrinsics_matrix- M_board_cam = construct_camera_extrinsics_matrix(rotation_vectors_all[cam_id, point_id],- translation_vectors_all[cam_id, point_id])- M_board = np.matmul(inverse(camera_extrinsics_matrix), M_board_cam)- rotation_vector, translation_vector = get_rotation_and_translation_vector_from_extrinsics_matrix(- M_board)- rotation_vectors[board_num] = rotation_vector- translation_vectors[board_num] = translation_vector-- x0 = np.zeros(total_cam_params + points3d.size + total_board_params)- x0[:total_cam_params] = cam_params- x0[total_cam_params: total_cam_params + points3d.size] = points3d.ravel()-- start_board = total_cam_params + points3d.size- x0[start_board: start_board + n_boards * 3] = rotation_vectors.ravel()- x0[start_board + n_boards * 3: start_board + n_boards * 6] = translation_vectors.ravel()-- return x0, n_cam_params-- def get_mean_reprojection_error(self, points2d, median=False):- triangulated_points3d = self.triangulate(points2d)- errors = self.calculate_reprojection_error(triangulated_points3d, points2d, mean=True)- if median:- return np.median(errors)- else:- return np.mean(errors)diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/anipose_flavored_stuff/calibration_utilities.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/anipose_flavored_stuff/calibration_utilities.pydeleted file mode 100644index eda43b74..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/anipose_flavored_stuff/calibration_utilities.py+++ /dev/null@@ -1,85 +0,0 @@-import cv2-import numpy as np--from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.calibration_numpy_types import \- RotationVectorArray, \- TranslationVectorArray, ObjectPoints3D---def calculate_error_bounds(error_dict: dict[tuple[int, int], tuple[int, np.ndarray]]) -> tuple[float, float]:- """Calculate the maximum and minimum error bounds from an error dictionary.-- Args:- error_dict (Dict[Tuple[int, int], Tuple[int, np.ndarray]]): Dictionary containing error statistics- for camera pairs, where the key is a tuple of camera indices and the value is a tuple of- (number of observations, percentiles).-- Returns:- Tuple[float, float]: A tuple of (max_error, min_error) based on the percentiles of error means.- """- max_error = 0.0- min_error = float('inf')- for _, (_, percents) in error_dict.items():- max_error = max(percents[-1], max_error)- min_error = min(percents[0], min_error)- return max_error, min_error---def transform_points(points: ObjectPoints3D,- rotation_vector: RotationVectorArray,- translation_vector: TranslationVectorArray):- """Rotate points by given rotation vectors and translate.- Rodrigues' rotation formula is used.- """- theta = np.linalg.norm(rotation_vector, axis=1)[:, np.newaxis]- with np.errstate(invalid="ignore"):- v = rotation_vector / theta- v = np.nan_to_num(v)- dot = np.sum(points * v, axis=1)[:, np.newaxis]- cos_theta = np.cos(theta)- sin_theta = np.sin(theta)-- rotated = cos_theta * points + sin_theta * np.cross(v, points) + dot * (1 - cos_theta) * v-- return rotated + translation_vector---def construct_camera_extrinsics_matrix(rotation_vector: RotationVectorArray,- translation_vector: TranslationVectorArray) -> np.ndarray:- if rotation_vector.shape != (3,) or translation_vector.shape != (3,):- raise ValueError("Rotation vector and translation vector must have shape (3,)")- extrinsics_matrix = np.zeros((4, 4))- rotmat, _ = cv2.Rodrigues(rotation_vector)- extrinsics_matrix[:3, :3] = rotmat- extrinsics_matrix[:3, 3] = translation_vector.flatten()- extrinsics_matrix[3, 3] = 1- return extrinsics_matrix---def get_rotation_and_translation_vector_from_extrinsics_matrix(extrinsics_matrix: np.ndarray) -> tuple[- np.ndarray, np.ndarray]:- if extrinsics_matrix.shape != (4, 4):- raise ValueError("Extrinsics matrix must be a 4x4 matrix")- rotation_vector = cv2.Rodrigues(extrinsics_matrix[:3, :3])[0].flatten()- translation_vector = extrinsics_matrix[:3, 3].flatten()- return rotation_vector, translation_vector---def get_error_dict(errors_full, min_points=10):- n_cams = errors_full.shape[0]- errors_norm = np.linalg.norm(errors_full, axis=2)-- good = ~np.isnan(errors_full[:, :, 0])-- error_dict = dict()-- for i in range(n_cams):- for j in range(i + 1, n_cams):- subset = good[i] & good[j]- err_subset = errors_norm[:, subset][[i, j]]- err_subset_mean = np.mean(err_subset, axis=0)- if np.sum(subset) > min_points:- percents = np.percentile(err_subset_mean, [15, 75])- # percents = np.percentile(err_subset, [25, 75])- error_dict[(i, j)] = (err_subset.shape[1], percents)- return error_dictdiff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/anipose_flavored_stuff/triangulation_method.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/anipose_flavored_stuff/triangulation_method.pydeleted file mode 100644index d2068fd6..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/anipose_flavored_stuff/triangulation_method.py+++ /dev/null@@ -1,32 +0,0 @@-import numpy as np-from numba import jit---@jit(nopython=True, parallel=False)-def triangulate_simple(points2d: np.ndarray,- camera_matrices: np.ndarray) -> np.ndarray:- """- Triangulate 3D point from 2D points and camera matrices using the Direct Linear Transform (DLT) method.-- :param points2d: A 2D array of shape (N, 2), where N is the number of cameras. Each row represents the- 2D coordinates (x, y) of the point in the image plane of each camera.- :param camera_matrices: A 3D array of shape (N, 3, 4), where each element is a 3x4 camera projection matrix.- :return: A 1D array of shape (3,) representing the triangulated 3D point.- """-- number_of_cameras = camera_matrices.shape[0]- A = np.zeros((number_of_cameras * 2, 4))-- for i in range(number_of_cameras):- x, y = points2d[i]- mat = camera_matrices[i]- A[i * 2] = x * mat[2] - mat[0]- A[i * 2 + 1] = y * mat[2] - mat[1]-- _, _, vh = np.linalg.svd(A,- full_matrices=False) # CHECK - Ai said this could be set to False since " we only need the right singular vectors, which is more efficient." but we should check on this bc I don't know what that means lol-- points3d_xyzh = vh[-1]- points3d_xyzh /= points3d_xyzh[3] # Normalize the last element to 1-- return points3d_xyzh[:3]diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calculate_sparse_jacobian.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calculate_sparse_jacobian.pydeleted file mode 100644index 80e2d6ef..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calculate_sparse_jacobian.py+++ /dev/null@@ -1,82 +0,0 @@-import numpy as np-from scipy.sparse import dok_matrix, csr_matrix---def calculate_jacobian_sparsity(- pixel_points2d: np.ndarray,- ids: np.ndarray,- num_camera_params: int-) -> csr_matrix:- """- Calculate the sparsity pattern of the Jacobian matrix for bundle adjustment.-- Parameters:- - pixel_points2d (np.ndarray): CxNx2 array of 2D points where C is the number of cameras and N is the number of points.- - ids (np.ndarray): Unique identifiers for each set of 3D points (or boards? not sure what this referred to in the og code).- - num_camera_params (int): Number of parameters per camera.-- Returns:- - csr_matrix: Sparse matrix representing the Jacobian sparsity pattern.- """- num_cameras, num_points, _ = pixel_points2d.shape-- # Initialize indices for points and cameras- point_indices = np.arange(num_points)- camera_indices = np.arange(num_cameras)[:, np.newaxis]-- # Mask valid (non-NaN) 2D points- valid_points_mask = ~np.isnan(pixel_points2d).any(axis=2)-- # Remap unique IDs to a consecutive range- def remap_ids(original_ids: np.ndarray) -> np.ndarray:- unique_ids, remapped_ids = np.unique(original_ids, return_inverse=True)- return remapped_ids-- remapped_ids = remap_ids(ids)- num_boards = int(np.max(remapped_ids)) + 1- board_params_per_board = 6 # 3 for rotation and 3 for translation- total_board_params = num_boards * board_params_per_board-- # Calculate total parameters for reprojection and errors- total_reprojection_params = num_cameras * num_camera_params + num_points * 3- total_params = total_reprojection_params + total_board_params- num_valid_points = valid_points_mask.sum()- total_errors = num_valid_points + num_points * 3-- # Initialize sparse matrix for Jacobian- jacobian_sparsity = dok_matrix((total_errors, total_params), dtype=bool)-- # Populate sparse matrix based on valid points- valid_camera_indices = camera_indices[valid_points_mask]- valid_point_indices = point_indices[valid_points_mask]-- # Update camera parameters based on reprojection error- for param_index in range(num_camera_params):- jacobian_sparsity[np.arange(num_valid_points), valid_camera_indices * num_camera_params + param_index] = True-- # Update point positions based on reprojection error- for coord_index in range(3):- jacobian_sparsity[- np.arange(num_valid_points), num_cameras * num_camera_params + valid_point_indices * 3 + coord_index] = True-- # Update board parameters based on object points error- for coord_index in range(3):- for board_param_index in range(3):- jacobian_sparsity[- num_valid_points + point_indices * 3 + coord_index,- total_reprojection_params + remapped_ids * 3 + board_param_index- ] = True- jacobian_sparsity[- num_valid_points + point_indices * 3 + coord_index,- total_reprojection_params + num_boards * 3 + remapped_ids * 3 + board_param_index- ] = True-- # Update point positions based on object points error- for coord_index in range(3):- jacobian_sparsity[- num_valid_points + point_indices * 3 + coord_index,- num_cameras * num_camera_params + point_indices * 3 + coord_index- ] = True-- # Convert to csr_matrix for efficiency in future operations- return jacobian_sparsity.tocsr()diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/charuco_3d_models.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/charuco_3d_models.pydeleted file mode 100644index 8f6ccd18..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/charuco_3d_models.py+++ /dev/null@@ -1,356 +0,0 @@-from typing import Literal, Any--import numpy as np-from numpydantic import NDArray, Shape-from pydantic import BaseModel, ConfigDict, Field, field_serializer, model_serializer-from skellycam.core.types.type_overloads import CameraIdString---class Color(BaseModel):- """RGB color with alpha channel (0-1 range for Three.js compatibility)"""- model_config = ConfigDict(frozen=True)-- r: float = Field(ge=0.0, le=1.0)- g: float = Field(ge=0.0, le=1.0)- b: float = Field(ge=0.0, le=1.0)- a: float = Field(default=1.0, ge=0.0, le=1.0)-- @classmethod- def from_hex(cls, hex_color: str) -> "Color":- """Create color from hex string like '#FF5733' or 'FF5733'"""- hex_color = hex_color.lstrip('#')- if len(hex_color) == 6:- r, g, b = int(hex_color[0:2], 16), int(hex_color[2:4], 16), int(hex_color[4:6], 16)- return cls(r=r / 255.0, g=g / 255.0, b=b / 255.0)- raise ValueError(f"Invalid hex color: {hex_color}")-- @classmethod- def from_rgb_255(cls, r: int, g: int, b: int, a: float = 1.0) -> "Color":- """Create color from 0-255 RGB values"""- return cls(r=r / 255.0, g=g / 255.0, b=b / 255.0, a=a)-- def to_hex(self) -> str:- """Convert to hex string for Three.js"""- r = int(self.r * 255)- g = int(self.g * 255)- b = int(self.b * 255)- return f"#{r:02x}{g:02x}{b:02x}"-- @model_serializer- def _serialize(self) -> str:- """Serialize directly to hex string"""- return self.to_hex()---class Point3d(BaseModel):- """3D point in space - serializes to [x, y, z] array"""- model_config = ConfigDict(frozen=True)-- x: float- y: float- z: float-- @classmethod- def from_array(cls, array: np.ndarray) -> "Point3d":- """Create from numpy array [x, y, z]"""- if array.shape != (3,):- raise ValueError(f"Expected array of shape (3,), got {array.shape}")- return cls(x=float(array[0]), y=float(array[1]), z=float(array[2]))-- def to_array(self) -> np.ndarray:- """Convert to numpy array"""- return np.array([self.x, self.y, self.z], dtype=np.float32)-- @model_serializer- def _serialize(self) -> list[float]:- """Serialize directly to [x, y, z] list"""- return [self.x, self.y, self.z]---class Sphere3d(BaseModel):- """Sphere for rendering in Three.js"""- model_config = ConfigDict(frozen=True)-- id: str- position: Point3d- radius: float = Field(gt=0.0)- color: Color- opacity: float = Field(default=1.0, ge=0.0, le=1.0)- label: str | None = None---class Line3d(BaseModel):- """Line connecting two points for rendering in Three.js"""- model_config = ConfigDict(frozen=True)-- id: str- start: Point3d- end: Point3d- color: Color- thickness: float = Field(default=1.0, gt=0.0)- opacity: float = Field(default=1.0, ge=0.0, le=1.0)- dashed: bool = False---class CoordinateFrame3d(BaseModel):- """Coordinate frame showing X, Y, Z axes"""- model_config = ConfigDict(frozen=True)-- id: str- origin: Point3d- x_axis: Point3d- y_axis: Point3d- z_axis: Point3d- scale: float = Field(default=1.0, gt=0.0)- label: str | None = None---class BoardPose3d(BaseModel):- """Pose of the Charuco board in 3D space"""- model_config = ConfigDict(- arbitrary_types_allowed=True,- frozen=True- )-- rotation_vector: NDArray[Shape["3"], np.float32]- translation_vector: NDArray[Shape["3"], np.float32]- coordinate_frame: CoordinateFrame3d | None = None-- @field_serializer('rotation_vector', 'translation_vector')- def _serialize_vectors(self, value: np.ndarray) -> list[float]:- """Serialize numpy arrays to lists"""- return value.tolist()-- @classmethod- def create_with_frame(- cls,- rotation_vector: np.ndarray,- translation_vector: np.ndarray,- frame_id: str,- frame_scale: float = 0.1,- label: str | None = None- ) -> "BoardPose3d":- """Create board pose with coordinate frame for visualization"""- import cv2-- rotation_matrix, _ = cv2.Rodrigues(rotation_vector)- origin = Point3d.from_array(translation_vector)-- x_end = origin.to_array() + rotation_matrix[:, 0] * frame_scale- y_end = origin.to_array() + rotation_matrix[:, 1] * frame_scale- z_end = origin.to_array() + rotation_matrix[:, 2] * frame_scale-- coordinate_frame = CoordinateFrame3d(- id=frame_id,- origin=origin,- x_axis=Point3d.from_array(x_end),- y_axis=Point3d.from_array(y_end),- z_axis=Point3d.from_array(z_end),- scale=frame_scale,- label=label- )-- return cls(- rotation_vector=rotation_vector,- translation_vector=translation_vector,- coordinate_frame=coordinate_frame- )---class ArucoMarker3d(BaseModel):- """3D representation of an ArUco marker with 4 corner spheres"""- model_config = ConfigDict(frozen=True)-- marker_id: int- corner_spheres: list[Sphere3d] = Field(min_length=4, max_length=4)- edge_lines: list[Line3d] = Field(min_length=4, max_length=4)- center_sphere: Sphere3d | None = None---class Charuco3dData(BaseModel):- """Complete 3D visualization data for Charuco board detection"""- model_config = ConfigDict(- arbitrary_types_allowed=True,- frozen=True- )-- camera_id: CameraIdString- frame_number: int- coordinate_system: Literal["camera", "world"]-- charuco_corner_spheres: dict[int, Sphere3d]- charuco_corner_connections: list[Line3d]- aruco_markers: dict[int, ArucoMarker3d]- board_pose: BoardPose3d | None = None-- all_corner_count: int- detected_corner_count: int- detection_quality: float = Field(ge=0.0, le=1.0)-- @classmethod- def from_charuco_observation(- cls,- camera_id: CameraIdString,- frame_number: int,- charuco_observation: "CharucoObservation", # type: ignore- coordinate_system: Literal["camera", "world"] = "camera",- charuco_corner_radius: float = 0.005,- aruco_corner_radius: float = 0.003,- charuco_color: Color | None = None,- aruco_color: Color | None = None,- connection_color: Color | None = None,- ) -> "Charuco3dData":- """Create visualization data from CharucoObservation"""-- if charuco_color is None:- charuco_color = Color.from_hex("#00FF00")- if aruco_color is None:- aruco_color = Color.from_hex("#FF0000")- if connection_color is None:- connection_color = Color.from_hex("#FFFFFF")-- if coordinate_system == "camera":- if charuco_observation.detected_charuco_corners_in_camera_coordinates is None:- raise ValueError(- "Camera coordinates not computed. Call compute_board_pose_and_camera_coordinates first.")- corner_coords = charuco_observation.detected_charuco_corners_in_camera_coordinates- aruco_coords = charuco_observation.detected_aruco_markers_in_camera_coordinates- else:- corner_coords = charuco_observation.detected_charuco_corners_in_object_coordinates- aruco_coords = None-- charuco_corner_spheres: dict[int, Sphere3d] = {}- if (corner_coords is not None and- charuco_observation.detected_charuco_corner_ids is not None):- for i, corner_id in enumerate(charuco_observation.detected_charuco_corner_ids):- corner_id_int = int(corner_id)- position = Point3d.from_array(corner_coords[i])- charuco_corner_spheres[corner_id_int] = Sphere3d(- id=f"charuco_corner_{corner_id_int}",- position=position,- radius=charuco_corner_radius,- color=charuco_color,- label=f"C{corner_id_int}"- )-- charuco_corner_connections: list[Line3d] = []-- aruco_markers: dict[int, ArucoMarker3d] = {}- if (aruco_coords is not None and- charuco_observation.detected_aruco_marker_ids is not None):- for i, marker_id in enumerate(charuco_observation.detected_aruco_marker_ids):- marker_id_int = int(marker_id)- marker_corners = aruco_coords[i]-- corner_spheres = [- Sphere3d(- id=f"aruco_{marker_id_int}_corner_{j}",- position=Point3d.from_array(marker_corners[j]),- radius=aruco_corner_radius,- color=aruco_color,- label=None- )- for j in range(4)- ]-- edge_lines = [- Line3d(- id=f"aruco_{marker_id_int}_edge_{j}",- start=Point3d.from_array(marker_corners[j]),- end=Point3d.from_array(marker_corners[(j + 1) % 4]),- color=aruco_color,- thickness=2.0- )- for j in range(4)- ]-- center = np.mean(marker_corners, axis=0)- center_sphere = Sphere3d(- id=f"aruco_{marker_id_int}_center",- position=Point3d.from_array(center),- radius=aruco_corner_radius * 1.5,- color=aruco_color,- opacity=0.5,- label=f"A{marker_id_int}"- )-- aruco_markers[marker_id_int] = ArucoMarker3d(- marker_id=marker_id_int,- corner_spheres=corner_spheres,- edge_lines=edge_lines,- center_sphere=center_sphere- )-- board_pose = None- if charuco_observation.has_board_pose:- board_pose = BoardPose3d.create_with_frame(- rotation_vector=charuco_observation.charuco_board_rotation_vector,- translation_vector=charuco_observation.charuco_board_translation_vector,- frame_id=f"board_frame_{camera_id}",- frame_scale=0.1,- label=f"Board ({camera_id})"- )-- all_corner_count = len(charuco_observation.all_charuco_ids)- detected_corner_count = len(charuco_corner_spheres)- detection_quality = detected_corner_count / all_corner_count if all_corner_count > 0 else 0.0-- return cls(- camera_id=camera_id,- frame_number=frame_number,- coordinate_system=coordinate_system,- charuco_corner_spheres=charuco_corner_spheres,- charuco_corner_connections=charuco_corner_connections,- aruco_markers=aruco_markers,- board_pose=board_pose,- all_corner_count=all_corner_count,- detected_corner_count=detected_corner_count,- detection_quality=detection_quality- )---class MultiCameraCharuco3dData(BaseModel):- """Aggregated 3D data from multiple cameras"""- model_config = ConfigDict(frozen=True)-- frame_number: int- camera_data: dict[CameraIdString, Charuco3dData]- world_data: Charuco3dData | None = None-- def get_all_spheres(self) -> list[Sphere3d]:- """Get all spheres across all cameras for batch rendering"""- spheres = []- for cam_data in self.camera_data.values():- spheres.extend(cam_data.charuco_corner_spheres.values())- for marker in cam_data.aruco_markers.values():- spheres.extend(marker.corner_spheres)- if marker.center_sphere:- spheres.append(marker.center_sphere)- if self.world_data:- spheres.extend(self.world_data.charuco_corner_spheres.values())- return spheres-- def get_all_lines(self) -> list[Line3d]:- """Get all lines across all cameras for batch rendering"""- lines = []- for cam_data in self.camera_data.values():- lines.extend(cam_data.charuco_corner_connections)- for marker in cam_data.aruco_markers.values():- lines.extend(marker.edge_lines)- if self.world_data:- lines.extend(self.world_data.charuco_corner_connections)- return lines-- @model_serializer- def _serialize(self) -> dict[str, Any]:- """Custom serialization to flatten structure for efficient websocket transmission"""- return {- "frame_number": self.frame_number,- "cameras": {- camera_id: cam_data.model_dump()- for camera_id, cam_data in self.camera_data.items()- },- "all_spheres": [sphere.model_dump() for sphere in self.get_all_spheres()],- "all_lines": [line.model_dump() for line in self.get_all_lines()],- "world": self.world_data.model_dump() if self.world_data else None- }diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/charuco_image_overlay_render.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/charuco_image_overlay_render.pydeleted file mode 100644index 70ff79d5..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/charuco_image_overlay_render.py+++ /dev/null@@ -1,89 +0,0 @@-import logging--import numpy as np-from skellycam.core.types.type_overloads import CameraIdString-from skellytracker.trackers.charuco_tracker.charuco_observation import CharucoObservation--from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.calibration_display_helpers.charuco_python_converter import \- charuco_observation_to_overlay_data, charuco_observation_to_metadata-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.calibration_display_helpers.charuco_topology_python import \- create_charuco_topology-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.calibration_display_helpers.image_overlay_system import \- OverlayRenderer--logger = logging.getLogger(__name__)---class CameraOverlayRenderer:- """Manages overlay rendering for a single camera using the overlay system."""-- def __init__(- self,- *,- camera_id: CameraIdString,- image_width: int,- image_height: int,- ):- self.camera_id = camera_id- self.image_width = image_width- self.image_height = image_height-- # Create topology based on pipeline config- self.topology = create_charuco_topology(- width=self.image_width,- height=self.image_height,- show_charuco_corners=True,- show_charuco_ids=True,- show_aruco_markers=True,- show_aruco_ids=True,- show_board_outline=False, # Can make configurable- max_charuco_corners=100,- max_aruco_markers=30,- )-- # Create renderer- self.renderer = OverlayRenderer(topology=self.topology)-- logger.info(- f"Initialized overlay renderer for camera {camera_id} "- f"({image_width}x{image_height})"- )-- def annotate_image(- self,- *,- image: np.ndarray,- charuco_observation: CharucoObservation,- total_frames: int | None = None,- ) -> np.ndarray:- """- Annotate image with charuco detection overlay.-- Args:- image: OpenCV image (BGR numpy array)- charuco_observation: Detection results- total_frames: Total number of frames for progress display-- Returns:- Annotated image (BGR numpy array)- """- try:- # Convert observation to overlay format- points = charuco_observation_to_overlay_data(charuco_observation)- metadata = charuco_observation_to_metadata(- charuco_observation,- total_frames=total_frames- )-- # Render overlay- return self.renderer.composite_on_image(- image=image,- points=points,- metadata=metadata- )-- except Exception as e:- logger.warning(- f"Failed to annotate image for camera {self.camera_id}: {e}"- )- return image # Return original image if annotation failsdiff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/charuco_python_converter.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/charuco_python_converter.pydeleted file mode 100644index 84e210d1..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/charuco_python_converter.py+++ /dev/null@@ -1,126 +0,0 @@-"""-Convert CharucoObservation to overlay-compatible data format.-"""--from typing import Any--import numpy as np-from skellytracker.trackers.charuco_tracker.charuco_observation import CharucoObservation---def charuco_observation_to_overlay_data(- observation: CharucoObservation-) -> dict[str, dict[str, np.ndarray]]:- """- Convert CharucoObservation to overlay points format.-- Returns nested dict: {data_type: {point_name: [x, y]}}-- Structure:- - 'charuco': Charuco corner points (charuco_0, charuco_1, ...)- - 'aruco': ArUco marker corners (aruco_0_corner_0, aruco_0_corner_1, ...)- """- points: dict[str, dict[str, np.ndarray]] = {- 'charuco': {},- 'aruco': {}- }-- # Add detected Charuco corners- if not observation.charuco_empty:- for corner_id, corner_coords in observation.charuco_corners_dict.items():- points['charuco'][f'charuco_{corner_id}'] = corner_coords-- # Add detected ArUco marker corners- if not observation.aruco_empty:- for marker_id, marker_corners in observation.aruco_corners_dict.items():- # ArUco markers have 4 corners- for corner_idx in range(4):- corner_name = f'aruco_{marker_id}_corner_{corner_idx}'- points['aruco'][corner_name] = marker_corners[corner_idx]-- return points---def charuco_observation_to_metadata(- observation: CharucoObservation,- total_frames: int | None = None-) -> dict[str, Any]:- """- Extract metadata from CharucoObservation for display.- """- metadata: dict[str, Any] = {- 'frame_idx': observation.frame_number,- 'total_frames': total_frames or 0,- 'n_charuco_detected': 0 if observation.charuco_empty else len(observation.detected_charuco_corner_ids),- 'n_charuco_total': len(observation.all_charuco_ids),- 'n_aruco_detected': 0 if observation.aruco_empty else len(observation.detected_aruco_marker_ids),- 'n_aruco_total': len(observation.all_aruco_ids),- 'image_width': observation.image_size[0],- 'image_height': observation.image_size[1],- }-- # Add pose info if available- if observation.charuco_board_translation_vector is not None:- metadata['has_pose'] = True- metadata['translation'] = observation.charuco_board_translation_vector.tolist()- metadata['rotation'] = observation.charuco_board_rotation_vector.tolist()- else:- metadata['has_pose'] = False-- return metadata---def stream_charuco_observations(- observations: list[CharucoObservation]-) -> tuple[list[dict[str, dict[str, np.ndarray]]], list[dict[str, Any]]]:- """- Convert a list of observations to overlay format for batch processing.-- Returns:- tuple of (points_list, metadata_list)- """- points_list = []- metadata_list = []-- total_frames = len(observations)-- for obs in observations:- points = charuco_observation_to_overlay_data(obs)- metadata = charuco_observation_to_metadata(obs, total_frames)-- points_list.append(points)- metadata_list.append(metadata)-- return points_list, metadata_list---# Example usage with your existing code:-"""-from .image_overlay_system import overlay_image-from create_charuco_topology import create_charuco_topology--# Setup topology once-topology = create_charuco_topology(- width=1920,- height=1080,- show_charuco_corners=True,- show_charuco_ids=True,- show_aruco_markers=True,- show_aruco_ids=True-)--# For each frame-observation: CharucoObservation = ... # Your detection result--# Convert to overlay format-points = charuco_observation_to_overlay_data(observation)-metadata = charuco_observation_to_metadata(observation, total_frames=1000)--# Render-annotated_frame = overlay_image(- image=frame,- topology=topology,- points=points,- metadata=metadata-)-"""diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/charuco_topology_python.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/charuco_topology_python.pydeleted file mode 100644index b081f629..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/charuco_topology_python.py+++ /dev/null@@ -1,258 +0,0 @@-"""-Create Charuco board overlay topology with configurable visualization options.-"""--import numpy as np--from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.calibration_display_helpers.image_overlay_system import (- OverlayTopology,- ComputedPoint,- PointElement,- LineElement,- TextElement,- PointStyle,- LineStyle,- TextStyle,-)---def create_charuco_topology(- *,- width: int,- height: int,- show_charuco_corners: bool = True,- show_charuco_ids: bool = True,- show_aruco_markers: bool = True,- show_aruco_ids: bool = True,- show_board_outline: bool = True,- max_charuco_corners: int = 100,- max_aruco_markers: int = 30,-) -> OverlayTopology:- """- Create a Charuco board overlay topology.-- Args:- width: Image width in pixels- height: Image height in pixels- show_charuco_corners: Show detected Charuco corner points- show_charuco_ids: Show Charuco corner ID labels- show_aruco_markers: Show detected ArUco marker outlines- show_aruco_ids: Show ArUco marker ID labels- show_board_outline: Connect detected corners to show board outline- max_charuco_corners: Maximum number of Charuco corners to support- max_aruco_markers: Maximum number of ArUco markers to support-- Returns:- Configured OverlayTopology instance- """- topology = OverlayTopology(- name="charuco_board_tracking",- width=width,- height=height,- required_points=[]- )-- # === CHARUCO CORNERS ===-- if show_charuco_corners:- charuco_style = PointStyle(- radius=5,- fill='rgb(0, 255, 0)', # Green- stroke='rgb(0, 150, 0)',- stroke_width=2,- opacity=1.0- )-- for corner_id in range(max_charuco_corners):- topology.add(- element=PointElement(- name=f"charuco_corner_{corner_id}",- point_name=('charuco', f'charuco_{corner_id}'),- style=charuco_style,- label=str(corner_id) if show_charuco_ids else None,- label_offset=(8, -8),- label_style=TextStyle(- font_size=10,- font_family='Arial, sans-serif',- fill='rgb(0, 255, 0)',- stroke='black',- stroke_width=2,- text_anchor='start'- )- )- )-- # === ARUCO MARKERS ===-- if show_aruco_markers:- aruco_line_style = LineStyle(- stroke='rgb(255, 100, 0)', # Orange- stroke_width=3,- opacity=0.9- )-- aruco_corner_style = PointStyle(- radius=4,- fill='rgb(255, 150, 0)',- stroke='rgb(200, 80, 0)',- stroke_width=1,- opacity=1.0- )-- for marker_id in range(max_aruco_markers):- # Draw 4 corners- for corner_idx in range(4):- topology.add(- element=PointElement(- name=f"aruco_{marker_id}_corner_{corner_idx}",- point_name=('aruco', f'aruco_{marker_id}_corner_{corner_idx}'),- style=aruco_corner_style- )- )-- # Draw lines connecting corners (forming square)- connections = [- (0, 1), (1, 2), (2, 3), (3, 0)- ]-- for idx, (corner_a, corner_b) in enumerate(connections):- topology.add(- element=LineElement(- name=f"aruco_{marker_id}_line_{idx}",- point_a=('aruco', f'aruco_{marker_id}_corner_{corner_a}'),- point_b=('aruco', f'aruco_{marker_id}_corner_{corner_b}'),- style=aruco_line_style- )- )-- # Add marker ID label at center- if show_aruco_ids:- def compute_aruco_center(points: dict[str, dict[str, np.ndarray]],- mid: int = marker_id) -> np.ndarray:- """Compute center of ArUco marker from its 4 corners."""- if 'aruco' not in points:- return np.array([np.nan, np.nan])-- corners = []- for corner_idx in range(4):- corner_name = f'aruco_{mid}_corner_{corner_idx}'- if corner_name in points['aruco']:- corners.append(points['aruco'][corner_name])-- if not corners:- return np.array([np.nan, np.nan])-- stacked = np.stack(arrays=corners, axis=0)- return np.nanmean(a=stacked, axis=0)-- topology.computed_points.append(- ComputedPoint(- data_type='computed',- name=f'aruco_{marker_id}_center',- computation=lambda pts, mid=marker_id: compute_aruco_center(pts, mid),- description=f"Center of ArUco marker {marker_id}"- )- )-- topology.add(- element=TextElement(- name=f"aruco_{marker_id}_label",- point_name=('computed', f'aruco_{marker_id}_center'),- text=str(marker_id),- offset=(0, 0),- style=TextStyle(- font_size=14,- font_family='Arial, sans-serif',- fill='rgb(255, 255, 255)',- stroke='rgb(255, 100, 0)',- stroke_width=3,- font_weight='bold',- text_anchor='start'- )- )- )-- # === FRAME INFO ===-- topology.computed_points.append(- ComputedPoint(- data_type='computed',- name='info_corner',- computation=lambda pts: np.array([10.0, 25.0]),- description="Top-left corner for info text"- )- )-- def format_charuco_info(metadata: dict[str, object]) -> str:- """Generate dynamic frame info text."""- frame_idx = metadata.get('frame_idx', 0)- total_frames = metadata.get('total_frames', 0)- n_charuco = metadata.get('n_charuco_detected', 0)- n_charuco_total = metadata.get('n_charuco_total', 0)- n_aruco = metadata.get('n_aruco_detected', 0)- n_aruco_total = metadata.get('n_aruco_total', 0)- has_pose = metadata.get('has_pose', False)- pose_str = " | POSE ✓" if has_pose else ""-- return (f"Frame: {frame_idx}/{total_frames} | "- f"Charuco: {n_charuco}/{n_charuco_total} | "- f"ArUco: {n_aruco}/{n_aruco_total}{pose_str}")-- topology.add(- element=TextElement(- name="frame_info",- point_name=('computed', 'info_corner'),- text=format_charuco_info,- offset=(0, 0),- style=TextStyle(- font_size=16,- font_family='Consolas, monospace',- fill='white',- stroke='black',- stroke_width=2,- text_anchor='start'- )- )- )-- # === DETECTION STATUS ===-- topology.computed_points.append(- ComputedPoint(- data_type='computed',- name='status_corner',- computation=lambda pts: np.array([10.0, 55.0]),- description="Status text position"- )- )-- def format_status(metadata: dict[str, object]) -> str:- """Generate status message."""- n_charuco = metadata.get('n_charuco_detected', 0)- n_aruco = metadata.get('n_aruco_detected', 0)-- if n_charuco == 0 and n_aruco == 0:- return "⚠ NO BOARD DETECTED"- elif n_charuco < 4:- return "⚠ INSUFFICIENT CORNERS"- else:- return "✓ BOARD DETECTED"-- topology.add(- element=TextElement(- name="status_info",- point_name=('computed', 'status_corner'),- text=format_status,- offset=(0, 0),- style=TextStyle(- font_size=14,- font_family='Arial, sans-serif',- fill='rgb(0, 255, 0)',- stroke='black',- stroke_width=2,- text_anchor='start'- )- )- )-- return topologydiff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/image_overlay_system.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/image_overlay_system.pydeleted file mode 100644index 15ebb5a7..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/image_overlay_system.py+++ /dev/null@@ -1,514 +0,0 @@-"""-OPTIMIZED overlay rendering system using OpenCV (much faster than PIL).-Key optimizations:-- Uses OpenCV drawing (no PIL conversions)-- Caches fonts and computed values-- Minimal allocations-- Vectorized operations where possible-"""--import json-from abc import ABC, abstractmethod-from typing import Any, Callable--import cv2-import numpy as np-from pydantic import BaseModel, Field, ConfigDict---# ============================================================================-# STYLE CLASSES (unchanged)-# ============================================================================--class PointStyle(BaseModel):- radius: int = 3- fill: str = 'rgb(0, 255, 0)'- stroke: str | None = None- stroke_width: int | None = None- opacity: float = 1.0---class LineStyle(BaseModel):- stroke: str = 'rgb(255, 55, 55)'- stroke_width: int = 2- opacity: float = 1.0- stroke_dasharray: str | None = None---class TextStyle(BaseModel):- font_size: int = 12- font_family: str = 'Arial, sans-serif'- fill: str = 'white'- stroke: str | None = 'black'- stroke_width: int | None = 1- font_weight: str = 'normal'- text_anchor: str = 'start'---# ============================================================================-# POINT REFERENCE SYSTEM (unchanged)-# ============================================================================--class PointReference(BaseModel):- data_type: str- name: str-- @classmethod- def parse(cls, *, reference: str | tuple[str, str]) -> "PointReference":- if isinstance(reference, PointReference):- return reference- elif isinstance(reference, tuple):- return cls(data_type=reference[0], name=reference[1])- elif isinstance(reference, str):- if '.' in reference:- parts = reference.split('.', maxsplit=1)- elif '/' in reference:- parts = reference.split('/', maxsplit=1)- else:- raise ValueError(f"Invalid point reference string: {reference}")- if len(parts) != 2:- raise ValueError(f"Invalid point reference: {reference}")- return cls(data_type=parts[0], name=parts[1])- else:- raise ValueError(f"Invalid reference type: {type(reference)}")-- def get_point(self, *, points: dict[str, dict[str, np.ndarray]]) -> np.ndarray | None:- data_type_dict = points.get(self.data_type)- if data_type_dict is None:- return None- return data_type_dict.get(self.name)-- def __str__(self) -> str:- return f"{self.data_type}.{self.name}"---def is_valid_point(*, point: np.ndarray | None) -> bool:- return point is not None and not np.isnan(point).any()---# ============================================================================-# ELEMENT CLASSES - OPTIMIZED WITH CV2-# ============================================================================--class OverlayElement(BaseModel, ABC):- model_config = ConfigDict(arbitrary_types_allowed=True)- element_type: str- name: str- visible: bool = True-- @abstractmethod- def render_cv2(- self,- *,- image: np.ndarray,- points: dict[str, dict[str, np.ndarray]],- metadata: dict[str, Any],- parse_rgb: Callable[[str], tuple[int, int, int]]- ) -> None:- """Render directly on OpenCV image (in-place)."""- pass---class PointElement(OverlayElement):- element_type: str = 'point'- point_ref: PointReference- style: PointStyle = Field(default_factory=PointStyle)- label: str | None = None- label_offset: tuple[float, float] = (5, -5)- label_style: TextStyle = Field(default_factory=TextStyle)-- def __init__(self, *, point_name: str | tuple[str, str] | PointReference, **kwargs: Any):- point_ref = PointReference.parse(reference=point_name)- super().__init__(point_ref=point_ref, **kwargs)-- def render_cv2(- self,- *,- image: np.ndarray,- points: dict[str, dict[str, np.ndarray]],- metadata: dict[str, Any],- parse_rgb: Callable[[str], tuple[int, int, int]]- ) -> None:- point = self.point_ref.get_point(points=points)- if not is_valid_point(point=point):- return-- x, y = int(point[0]), int(point[1])- r = self.style.radius- fill_color = parse_rgb(self.style.fill)-- # Draw filled circle- cv2.circle(img=image, center=(x, y), radius=r, color=fill_color, thickness=-1)-- # Draw stroke if specified- if self.style.stroke and self.style.stroke_width:- stroke_color = parse_rgb(self.style.stroke)- cv2.circle(img=image, center=(x, y), radius=r, color=stroke_color,- thickness=self.style.stroke_width)-- # Draw label- if self.label:- label_x = int(x + self.label_offset[0])- label_y = int(y + self.label_offset[1])-- font = cv2.FONT_HERSHEY_SIMPLEX- font_scale = self.label_style.font_size / 30.0- thickness = max(1, self.label_style.stroke_width or 1)-- # Draw stroke- if self.label_style.stroke:- stroke_color = parse_rgb(self.label_style.stroke)- cv2.putText(img=image, text=self.label, org=(label_x, label_y),- fontFace=font, fontScale=font_scale, color=stroke_color,- thickness=thickness + 2, lineType=cv2.LINE_AA)-- # Draw text- fill_color = parse_rgb(self.label_style.fill)- cv2.putText(img=image, text=self.label, org=(label_x, label_y),- fontFace=font, fontScale=font_scale, color=fill_color,- thickness=thickness, lineType=cv2.LINE_AA)---class LineElement(OverlayElement):- element_type: str = 'line'- point_a_ref: PointReference- point_b_ref: PointReference- style: LineStyle = Field(default_factory=LineStyle)-- def __init__(- self,- *,- point_a: str | tuple[str, str] | PointReference,- point_b: str | tuple[str, str] | PointReference,- **kwargs: Any- ):- point_a_ref = PointReference.parse(reference=point_a)- point_b_ref = PointReference.parse(reference=point_b)- super().__init__(point_a_ref=point_a_ref, point_b_ref=point_b_ref, **kwargs)-- def render_cv2(- self,- *,- image: np.ndarray,- points: dict[str, dict[str, np.ndarray]],- metadata: dict[str, Any],- parse_rgb: Callable[[str], tuple[int, int, int]]- ) -> None:- pt_a = self.point_a_ref.get_point(points=points)- pt_b = self.point_b_ref.get_point(points=points)-- if not (is_valid_point(point=pt_a) and is_valid_point(point=pt_b)):- return-- p1 = (int(pt_a[0]), int(pt_a[1]))- p2 = (int(pt_b[0]), int(pt_b[1]))- color = parse_rgb(self.style.stroke)-- cv2.line(img=image, pt1=p1, pt2=p2, color=color,- thickness=self.style.stroke_width, lineType=cv2.LINE_AA)---class CircleElement(OverlayElement):- element_type: str = 'circle'- center_ref: PointReference- radius: float- style: PointStyle = Field(default_factory=PointStyle)-- def __init__(self, *, center_point: str | tuple[str, str] | PointReference, **kwargs: Any):- center_ref = PointReference.parse(reference=center_point)- super().__init__(center_ref=center_ref, **kwargs)-- def render_cv2(- self,- *,- image: np.ndarray,- points: dict[str, dict[str, np.ndarray]],- metadata: dict[str, Any],- parse_rgb: Callable[[str], tuple[int, int, int]]- ) -> None:- center = self.center_ref.get_point(points=points)- if not is_valid_point(point=center):- return-- cx, cy = int(center[0]), int(center[1])- r = int(self.radius)- fill_color = parse_rgb(self.style.fill)-- cv2.circle(img=image, center=(cx, cy), radius=r, color=fill_color, thickness=-1)-- if self.style.stroke and self.style.stroke_width:- stroke_color = parse_rgb(self.style.stroke)- cv2.circle(img=image, center=(cx, cy), radius=r, color=stroke_color,- thickness=self.style.stroke_width)---class CrosshairElement(OverlayElement):- element_type: str = 'crosshair'- center_ref: PointReference- size: float = 10- style: LineStyle = Field(default_factory=LineStyle)-- def __init__(self, *, center_point: str | tuple[str, str] | PointReference, **kwargs: Any):- center_ref = PointReference.parse(reference=center_point)- super().__init__(center_ref=center_ref, **kwargs)-- def render_cv2(- self,- *,- image: np.ndarray,- points: dict[str, dict[str, np.ndarray]],- metadata: dict[str, Any],- parse_rgb: Callable[[str], tuple[int, int, int]]- ) -> None:- center = self.center_ref.get_point(points=points)- if not is_valid_point(point=center):- return-- cx, cy = int(center[0]), int(center[1])- size = int(self.size)- color = parse_rgb(self.style.stroke)-- cv2.line(img=image, pt1=(cx - size, cy), pt2=(cx + size, cy),- color=color, thickness=self.style.stroke_width, lineType=cv2.LINE_AA)- cv2.line(img=image, pt1=(cx, cy - size), pt2=(cx, cy + size),- color=color, thickness=self.style.stroke_width, lineType=cv2.LINE_AA)---class TextElement(OverlayElement):- element_type: str = 'text'- point_ref: PointReference- text: str | Callable[[dict[str, Any]], str]- offset: tuple[float, float] = (0, 0)- style: TextStyle = Field(default_factory=TextStyle)-- def __init__(self, *, point_name: str | tuple[str, str] | PointReference, **kwargs: Any):- point_ref = PointReference.parse(reference=point_name)- super().__init__(point_ref=point_ref, **kwargs)-- def render_cv2(- self,- *,- image: np.ndarray,- points: dict[str, dict[str, np.ndarray]],- metadata: dict[str, Any],- parse_rgb: Callable[[str], tuple[int, int, int]]- ) -> None:- point = self.point_ref.get_point(points=points)- if not is_valid_point(point=point):- return-- x = int(point[0] + self.offset[0])- y = int(point[1] + self.offset[1])-- # Get text- if callable(self.text):- text_to_render = self.text(metadata)- else:- text_to_render = self.text-- font = cv2.FONT_HERSHEY_SIMPLEX- font_scale = self.style.font_size / 30.0- thickness = max(1, self.style.stroke_width or 1)-- # Draw stroke (simplified - just one extra layer)- if self.style.stroke:- stroke_color = parse_rgb(self.style.stroke)- cv2.putText(img=image, text=text_to_render, org=(x, y),- fontFace=font, fontScale=font_scale, color=stroke_color,- thickness=thickness + 2, lineType=cv2.LINE_AA)-- # Draw text- fill_color = parse_rgb(self.style.fill)- cv2.putText(img=image, text=text_to_render, org=(x, y),- fontFace=font, fontScale=font_scale, color=fill_color,- thickness=thickness, lineType=cv2.LINE_AA)---class EllipseElement(OverlayElement):- element_type: str = 'ellipse'- params_ref: PointReference- n_points: int = 100- style: LineStyle = Field(default_factory=LineStyle)- _ellipse_cache: dict[tuple, np.ndarray] = {}-- def __init__(self, *, params_point: str | tuple[str, str] | PointReference, **kwargs: Any):- params_ref = PointReference.parse(reference=params_point)- super().__init__(params_ref=params_ref, **kwargs)-- def render_cv2(- self,- *,- image: np.ndarray,- points: dict[str, dict[str, np.ndarray]],- metadata: dict[str, Any],- parse_rgb: Callable[[str], tuple[int, int, int]]- ) -> None:- params = self.params_ref.get_point(points=points)- if params is None or len(params) != 5 or np.isnan(params).any():- return-- cx, cy, semi_major, semi_minor, rotation = params- center = (int(cx), int(cy))- axes = (int(semi_major), int(semi_minor))- angle = int(np.degrees(rotation))- color = parse_rgb(self.style.stroke)-- cv2.ellipse(img=image, center=center, axes=axes, angle=angle,- startAngle=0, endAngle=360, color=color,- thickness=self.style.stroke_width, lineType=cv2.LINE_AA)---# ============================================================================-# TOPOLOGY (unchanged structure)-# ============================================================================--class ComputedPoint(BaseModel):- model_config = ConfigDict(arbitrary_types_allowed=True)- data_type: str- name: str- computation: Callable[[dict[str, dict[str, np.ndarray]]], np.ndarray]- description: str = ""---class OverlayTopology(BaseModel):- model_config = ConfigDict(arbitrary_types_allowed=True)- name: str- required_points: list[tuple[str, str]] = Field(default_factory=list)- computed_points: list[ComputedPoint] = Field(default_factory=list)- elements: list[OverlayElement] = Field(default_factory=list)- width: int = 640- height: int = 480-- def add(self, *, element: OverlayElement) -> "OverlayTopology":- self.elements.append(element)- return self-- def to_json_dict(self) -> dict[str, Any]:- return {- 'name': self.name,- 'required_points': self.required_points,- 'width': self.width,- 'height': self.height,- 'elements': [json.loads(elem.model_dump_json()) for elem in self.elements]- }-- def to_json(self) -> str:- return json.dumps(self.to_json_dict(), indent=2)-- def save_json(self, *, filepath: str) -> None:- with open(filepath, 'w') as f:- f.write(self.to_json())---# ============================================================================-# OPTIMIZED RENDERER-# ============================================================================--class OverlayRenderer(BaseModel):- """OPTIMIZED: Uses OpenCV directly, no PIL conversions."""- model_config = ConfigDict(arbitrary_types_allowed=True)-- topology: OverlayTopology- color_map: dict[str, tuple[int, int, int]] = Field(default_factory=dict, init=False)-- def model_post_init(self, __context: Any) -> None:- """Initialize color map (BGR for OpenCV)."""- self.color_map = {- 'red': (0, 0, 255), 'green': (0, 255, 0),- 'blue': (255, 0, 0), 'yellow': (0, 255, 255),- 'lime': (0, 255, 0), 'white': (255, 255, 255),- 'black': (0, 0, 0), 'cyan': (255, 255, 0),- 'magenta': (255, 0, 255), 'orange': (0, 165, 255),- }-- def _parse_rgb(self, color: str) -> tuple[int, int, int]:- """Parse color to BGR tuple for OpenCV."""- color = color.strip().lower()-- if color.startswith('rgb(') and color.endswith(')'):- values = color[4:-1].split(',')- r, g, b = [int(v.strip()) for v in values]- return (b, g, r) # BGR for OpenCV-- return self.color_map.get(color, (255, 255, 255))-- def _compute_all_points(- self,- *,- points: dict[str, dict[str, np.ndarray]]- ) -> dict[str, dict[str, np.ndarray]]:- """Compute derived points WITHOUT deep copy."""- # OPTIMIZED: Share dictionaries when possible- all_points = points.copy() # Shallow copy is sufficient-- # Compute derived points- for computed in self.topology.computed_points:- try:- result = computed.computation(all_points)-- if computed.data_type not in all_points:- all_points[computed.data_type] = {}-- all_points[computed.data_type][computed.name] = result- except Exception:- # Silently skip failed computations- pass-- return all_points-- def composite_on_image(- self,- *,- image: np.ndarray,- points: dict[str, dict[str, np.ndarray]],- metadata: dict[str, Any] | None = None- ) -> np.ndarray:- """- OPTIMIZED: Draw directly on image copy using OpenCV.-- Args:- image: OpenCV BGR image- points: Nested dict of points- metadata: Optional metadata-- Returns:- Annotated BGR image- """- if metadata is None:- metadata = {}-- # OPTIMIZED: Single copy, no conversions- output = image.copy()-- all_points = self._compute_all_points(points=points)-- # Render all elements directly- for element in self.topology.elements:- if element.visible:- element.render_cv2(- image=output,- points=all_points,- metadata=metadata,- parse_rgb=self._parse_rgb- )-- return output---# ============================================================================-# CONVENIENCE FUNCTION-# ============================================================================--def overlay_image(- *,- image: np.ndarray,- topology: OverlayTopology,- points: dict[str, dict[str, np.ndarray]],- metadata: dict[str, Any] | None = None-) -> np.ndarray:- """Convenience function to render overlay on image."""- return OverlayRenderer(topology=topology).composite_on_image(- image=image,- points=points,- metadata=metadata- )diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_numpy_types.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_numpy_types.pydeleted file mode 100644index eba1efb0..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_numpy_types.py+++ /dev/null@@ -1,41 +0,0 @@-import numpy as np-from numpydantic import NDArray, Shape--ReprojectionError = float--ImagePoint2D = NDArray[Shape["2 pixelx_pixely"], np.float64]-ImagePoints2D = NDArray[Shape["* n_points, 2 pixelx_pixely"], np.float64]-ImagePoints2DByCamera = NDArray[Shape[- "* n_cams, * n_points, 2 pixelx_pixely"], np.float64] # e.g. Image coordinates of a point in 3d space projected onto each camera--ObjectPoint3D = NDArray[Shape["3 xyz"], np.float64]-ObjectPoints3D = NDArray[Shape["* n_points, 3 xyz"], np.float64]-PointIds = NDArray[Shape["* n_points"], np.int64]--RotationVectorArray = NDArray[Shape["3"], np.float64]-RotationMatrixArray = NDArray[Shape["3 rows, 3 columns"], np.float64]-QuaternionArray = NDArray[Shape["4 xyzw"], np.float64]-TranslationVectorArray = NDArray[Shape["3"], np.float64]-RotationVectorsByCamera = NDArray[Shape["* n_cams, 3"], np.float64]-TranslationVectorsByCamera = NDArray[Shape["* n_cams, 3"], np.float64]--CameraMatrixArray = NDArray[Shape["3 rows, 3 columns"], np.float64]-CameraExtrinsicsMatrix = NDArray[Shape["3 rows, 4 columns"], np.float64]-CameraMatrixByCamera = NDArray[Shape["* n_cams, 3 rows, 3 columns"], np.float64]-CameraExtrinsicsMatrixByCamera = NDArray[Shape["* n_cams, 4 rows, 4 columns"], np.float64]-TransformationMatrixArray = NDArray[Shape[- "4 rows, 4 columns"], np.float64] # 4x4 matrix that transforms points from the camera coordinate system to the world coordinate system. 3x3 in the upper left is the rotation matrix, and the rightmost column is the translation vector. The bottom row is [0, 0, 0, 1] (where the 1 is the homogeneous coordinate, which makes the matrix invertible and provides the scale factor for the translation vector to put it in spatial coordinates--CameraDistortionCoefficientsArray = NDArray[- Shape["4-14 k1_k2_p1_p2_k3_k4_k5_k6"], np.float64] # Can be 4,5,8,12, or 14 elements--ExtrinsicsParameters = NDArray[Shape["6 translation_rotation"], np.float64] # 3 for rotation, 3 for translation-IntrinsicsParameters = NDArray[- Shape["*, ..."], np.float64] # focal length, variable number of distortion coefficients (2, 4, 5, 8, 12, or 14)--ExtrinsicsParametersByCamera = NDArray[Shape["* n_cams, 6 translation_rotation"], np.float64]-IntrinsicsParametersByCamera = NDArray[Shape["* n_cams, * focal_length_distortion"], np.float64]--JacobianMatrixArray = NDArray[Shape["* m_n_error_function_returns, * n_parameters"], np.float64]--SparseBundleOptimizerGuess1D = NDArray[Shape["* n_parameters"], np.float64]diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/charuco_view_optimizer.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/charuco_view_optimizer.pydeleted file mode 100644index f1d8dfef..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/charuco_view_optimizer.py+++ /dev/null@@ -1,372 +0,0 @@-import logging-from typing import Protocol--import numpy as np-from pydantic import BaseModel, Field-from scipy.spatial.distance import cdist-from sklearn.cluster import KMeans--logger = logging.getLogger(__name__)---class ObservationProtocol(Protocol):- """Protocol for observations that can be optimized."""- detected_charuco_corners_image_coordinates: np.ndarray- frame_number: int---class CharucoViewSelectionConfig(BaseModel):- """Configuration for view selection optimization."""- target_view_count: int = Field(default=30, ge=1, le=200)- initial_view_count: int = Field(default=15, ge=5, le=50)- grid_size: tuple[int, int] = Field(default=(3, 3))- min_coverage_per_cell: float = Field(default=0.5, ge=0.0, le=1.0)- coverage_weight: float = Field(default=0.6, ge=0.0, le=1.0)- diversity_weight: float = Field(default=0.4, ge=0.0, le=1.0)---class CharucoViewOptimizer:- """- Two-stage view optimizer for camera calibration:-- Stage 1: Select initial subset using coverage + spatial diversity (no pose info needed)- Stage 2: Select optimal subset using coverage + pose diversity (requires pose estimates)-- Workflow:- 1. Call select_initial_views() -> get indices for quick calibration- 2. Calibrate camera using initial views (external)- 3. Estimate poses for ALL views using calibration (external)- 4. Call select_final_views() with pose data -> get optimal subset- 5. Perform final calibration on optimal subset (external)-- References:- - OpenCV recommends 20-40 images for calibration- - Above 100 images provides diminishing returns with exponential computation cost- """-- def __init__(- self,- image_size: tuple[int, int],- config: CharucoViewSelectionConfig = CharucoViewSelectionConfig()- ):- self.image_size = image_size- self.config = config- self.width = image_size[0]- self.height = image_size[1]-- def select_initial_views(- self,- observations: list[ObservationProtocol]- ) -> list[int]:- """- Stage 1: Select initial subset for bootstrapping calibration.-- Uses only coverage and spatial diversity (no pose information required).- This subset should be used for a quick initial calibration to obtain- camera parameters for pose estimation.-- Args:- observations: All available observations-- Returns:- Indices of observations for initial calibration-- Raises:- ValueError: If no observations provided- """- if len(observations) == 0:- raise ValueError("No observations provided")-- target = self.config.initial_view_count-- if len(observations) <= target:- logger.info(f"Using all {len(observations)} views for initial calibration")- return list(range(len(observations)))-- logger.info(f"Selecting {target} initial views from {len(observations)} for bootstrapping")-- coverage_scores = self._compute_coverage_scores(observations=observations)- diversity_scores = self._compute_spatial_diversity_scores(observations=observations)-- combined_scores = (- self.config.coverage_weight * coverage_scores +- self.config.diversity_weight * diversity_scores- )-- selected_indices = np.argsort(combined_scores)[-target:]- selected_indices = sorted(selected_indices.tolist())-- logger.info(f"Selected {len(selected_indices)} initial views")- return selected_indices-- def select_final_views(- self,- observations: list[ObservationProtocol],- rotation_vectors: list[np.ndarray],- translation_vectors: list[np.ndarray]- ) -> list[int]:- """- Stage 2: Select optimal final subset using pose information.-- Uses coverage + pose-based diversity for optimal view selection.- Requires pose estimates for ALL observations (from initial calibration).-- Args:- observations: All available observations- rotation_vectors: Rotation vectors for all observations (from pose estimation)- translation_vectors: Translation vectors for all observations (from pose estimation)-- Returns:- Indices of observations for final calibration-- Raises:- ValueError: If inputs are invalid or mismatched lengths- """- if len(observations) == 0:- raise ValueError("No observations provided")-- if len(rotation_vectors) != len(observations):- raise ValueError(- f"Rotation vectors length ({len(rotation_vectors)}) "- f"must match observations length ({len(observations)})"- )-- if len(translation_vectors) != len(observations):- raise ValueError(- f"Translation vectors length ({len(translation_vectors)}) "- f"must match observations length ({len(observations)})"- )-- target = self.config.target_view_count-- if len(observations) <= target:- logger.info(f"Using all {len(observations)} views for final calibration")- return list(range(len(observations)))-- logger.info(f"Selecting {target} optimal views from {len(observations)}")-- coverage_scores = self._compute_coverage_scores(observations=observations)- diversity_scores = self._compute_pose_diversity_scores(- rotation_vectors=rotation_vectors,- translation_vectors=translation_vectors- )-- combined_scores = (- self.config.coverage_weight * coverage_scores +- self.config.diversity_weight * diversity_scores- )-- selected_indices = np.argsort(combined_scores)[-target:]- selected_indices = sorted(selected_indices.tolist())-- logger.info(- f"Selected {len(selected_indices)} final views - "- f"mean coverage: {coverage_scores[selected_indices].mean():.3f}, "- f"mean diversity: {diversity_scores[selected_indices].mean():.3f}"- )-- return selected_indices-- def _compute_coverage_scores(- self,- observations: list[ObservationProtocol]- ) -> np.ndarray:- """- Compute spatial coverage score for each observation.-- Score based on:- 1. Number of grid cells covered- 2. Uniformity of coverage across cells- 3. Edge/corner coverage bonus- """- grid_rows, grid_cols = self.config.grid_size- cell_height = self.height / grid_rows- cell_width = self.width / grid_cols-- scores = np.zeros(len(observations))-- for idx, obs in enumerate(observations):- points = obs.detected_charuco_corners_image_coordinates- if len(points) == 0:- scores[idx] = 0.0- continue-- grid_coverage = np.zeros((grid_rows, grid_cols), dtype=bool)-- for point in points:- x, y = point[0], point[1]- grid_row = int(min(y / cell_height, grid_rows - 1))- grid_col = int(min(x / cell_width, grid_cols - 1))- grid_coverage[grid_row, grid_col] = True-- coverage_ratio = grid_coverage.sum() / (grid_rows * grid_cols)-- edge_bonus = self._compute_edge_coverage_bonus(- points=points,- grid_coverage=grid_coverage,- grid_rows=grid_rows,- grid_cols=grid_cols- )-- density_bonus = min(len(points) / 50.0, 1.0) * 0.2-- scores[idx] = coverage_ratio + edge_bonus + density_bonus-- if scores.max() > 0:- scores = scores / scores.max()-- return scores-- def _compute_edge_coverage_bonus(- self,- points: np.ndarray,- grid_coverage: np.ndarray,- grid_rows: int,- grid_cols: int- ) -> float:- """Compute bonus for covering edge and corner regions."""- top_edge = grid_coverage[0, :].any()- bottom_edge = grid_coverage[-1, :].any()- left_edge = grid_coverage[:, 0].any()- right_edge = grid_coverage[:, -1].any()-- edge_coverage_count = sum([top_edge, bottom_edge, left_edge, right_edge])-- corners_covered = 0- corner_regions = [- (0, 0), (0, grid_cols - 1),- (grid_rows - 1, 0), (grid_rows - 1, grid_cols - 1)- ]- for row, col in corner_regions:- if grid_coverage[row, col]:- corners_covered += 1-- edge_bonus = (edge_coverage_count / 4.0) * 0.15- corner_bonus = (corners_covered / 4.0) * 0.15-- return edge_bonus + corner_bonus-- def _compute_pose_diversity_scores(- self,- rotation_vectors: list[np.ndarray],- translation_vectors: list[np.ndarray]- ) -> np.ndarray:- """- Compute diversity scores based on pose clustering.-- Views with unique poses get higher scores.- """- if len(rotation_vectors) == 0:- raise ValueError("No rotation vectors provided")-- pose_features = []- for rvec, tvec in zip(rotation_vectors, translation_vectors):- rvec_norm = rvec.flatten() / (np.linalg.norm(rvec) + 1e-8)- tvec_norm = tvec.flatten() / (np.linalg.norm(tvec) + 1e-8)- pose_features.append(np.concatenate([rvec_norm, tvec_norm]))-- pose_features_array = np.array(pose_features)-- n_clusters = min(self.config.target_view_count, len(pose_features_array))- if n_clusters < 2:- return np.ones(len(pose_features_array))-- try:- kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10)- cluster_labels = kmeans.fit_predict(pose_features_array)- except Exception as e:- logger.warning(f"Pose clustering failed: {e}, using uniform scores")- return np.ones(len(pose_features_array))-- scores = np.zeros(len(pose_features_array))-- for cluster_id in range(n_clusters):- cluster_mask = cluster_labels == cluster_id- cluster_size = cluster_mask.sum()-- if cluster_size == 0:- continue-- cluster_center = kmeans.cluster_centers_[cluster_id]- cluster_points = pose_features_array[cluster_mask]-- distances = cdist(cluster_points, cluster_center.reshape(1, -1)).flatten()-- if distances.max() > 0:- normalized_distances = 1.0 - (distances / distances.max())- else:- normalized_distances = np.ones(len(distances))-- cluster_weight = 1.0 / np.sqrt(cluster_size)-- scores[cluster_mask] = normalized_distances * cluster_weight-- if scores.max() > 0:- scores = scores / scores.max()-- return scores-- def _compute_spatial_diversity_scores(- self,- observations: list[ObservationProtocol]- ) -> np.ndarray:- """- Compute diversity based on spatial distribution of points.-- Used in stage 1 when pose information is not available.- """- scores = np.zeros(len(observations))-- for idx, obs in enumerate(observations):- points = obs.detected_charuco_corners_image_coordinates- if len(points) < 2:- scores[idx] = 0.0- continue-- x_coords = points[:, 0]- y_coords = points[:, 1]-- x_spread = np.std(x_coords) / self.width- y_spread = np.std(y_coords) / self.height-- scores[idx] = (x_spread + y_spread) / 2.0-- if scores.max() > 0:- scores = scores / scores.max()-- return scores-- def compute_coverage_heatmap(- self,- observations: list[ObservationProtocol],- selected_indices: list[int] | None = None- ) -> np.ndarray:- """- Compute a heatmap showing coverage across the image.-- Args:- observations: All observations- selected_indices: Indices to visualize (if None, uses all observations)-- Returns:- Heatmap array of shape (grid_rows, grid_cols)- """- grid_rows, grid_cols = self.config.grid_size- cell_height = self.height / grid_rows- cell_width = self.width / grid_cols-- heatmap = np.zeros((grid_rows, grid_cols))-- indices_to_use = selected_indices if selected_indices is not None else range(len(observations))-- for idx in indices_to_use:- obs = observations[idx]- points = obs.detected_charuco_corners_image_coordinates-- for point in points:- x, y = point[0], point[1]- grid_row = int(min(y / cell_height, grid_rows - 1))- grid_col = int(min(x / cell_width, grid_cols - 1))- heatmap[grid_row, grid_col] += 1-- return heatmapdiff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/least_squares_optimizer.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/least_squares_optimizer.pydeleted file mode 100644index ffd417f7..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/least_squares_optimizer.py+++ /dev/null@@ -1,175 +0,0 @@-import numpy as np-from pydantic import BaseModel-from pydantic import model_validator-from scipy import optimize-from scipy.sparse import dok_matrix-from skellycam.core.types.type_overloads import CameraIdString-from typing_extensions import Self--from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.calibration_numpy_types import \- ImagePoints2D, ImagePoint2D, CameraExtrinsicsMatrix-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.camera_math_models import TransformationMatrix-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.single_camera_calibrator import \- CameraIntrinsicsEstimate-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.triangulate_points import undistort_points, \- calculate_reprojection_error, triangulate_point-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.shared_view_accumulator import MultiCameraTargetView, \- MultiFrameNumber---class SparseBundleOptimizer(BaseModel):- principal_camera_id: CameraIdString- initial_guess: dict[CameraIdString, CameraExtrinsicsMatrix]- image_points_by_camera: dict[CameraIdString, list[ImagePoint2D]]- camera_intrinsics: dict[CameraIdString, CameraIntrinsicsEstimate]- image_sizes: dict[CameraIdString, tuple[int, int]]-- @classmethod- def create(cls,- principal_camera_id: CameraIdString,- camera_extrinsics_by_camera_id: dict[CameraIdString, CameraExtrinsicsMatrix],- multi_camera_target_views: dict[MultiFrameNumber, MultiCameraTargetView],- camera_intrinsics: dict[CameraIdString, CameraIntrinsicsEstimate],- image_sizes: dict[CameraIdString, tuple[int, int]]- ) -> "SparseBundleOptimizer":- image_points_by_camera: dict[CameraIdString, list[ImagePoint2D]] = {camera_id: [] for camera_id in- camera_intrinsics.keys()}- for frame_number, target_view in multi_camera_target_views.items():- for camera_id, image_points in target_view.image_points_by_camera.items():- image_points_by_camera[camera_id].extend(image_points)- return cls(- image_points_by_camera=image_points_by_camera,- camera_intrinsics=camera_intrinsics,- initial_guess=camera_extrinsics_by_camera_id,- principal_camera_id=principal_camera_id,- image_sizes=image_sizes- )-- @model_validator(mode='after')- def validate(self) -> Self:- # make sure the principal camera is in all the keys, along with at least one other camera- if self.principal_camera_id not in self.initial_guess or len(self.initial_guess) < 2:- raise ValueError("Principal camera must be in the initial guess and there must be at least two cameras")- camera_ids = self.initial_guess.keys()- if not all([camera_ids == self.image_points_by_camera.keys(),- camera_ids == self.camera_intrinsics.keys(),- camera_ids == self.image_points_by_camera.keys(),- camera_ids == self.image_sizes.keys()]):- raise ValueError("All camera ids must be the same across all inputs")- for camera_id, image_points in self.image_points_by_camera.items():- if len(image_points) < 2:- raise ValueError(f"Camera {camera_id} must have at least two image points")- if len(image_points) != self.number_of_points:- raise ValueError(- f"Camera {camera_id} must have the same number of image points as the principal camera")- return self-- @property- def number_of_optimization_parameters(self) -> int:- return len(self.starting_guess_vector)-- @property- def number_of_parameters_per_camera(self) -> int:- return self.initial_guess[self.principal_camera_id].size-- @property- def number_of_points(self) -> int:- return len(self.image_points_by_camera[self.principal_camera_id])-- @property- def starting_guess_vector(self) -> list[float]:- starting_guess = []- for camera_id, extrinsics in self.initial_guess.items():- starting_guess.extend(extrinsics.flatten().tolist())- return starting_guess-- def optimize(self) -> optimize.OptimizeResult:-- # Set up optimization options- return optimize.least_squares(- fun=self.error_function,- x0=self.starting_guess_vector,- # jac_sparsity=self.get_jacobian_sparse_matrix(),- jac="3-point", # TODO- could prob use `callable` and calc the jacobian dynamically- f_scale=50.0, # TODO - Not sure where this number comes from- x_scale="jac",- loss="cauchy", # "linear", # TODO - try `soft_l1` or `cauchy`- # ftol=1e-4,- method="trf",- verbose=2,- bounds=(-np.inf, np.inf), # TODO - set bounds to reasonable values- max_nfev=1000,- kwargs=dict(camera_intrinsics=self.camera_intrinsics,- image_points_by_camera=self.image_points_by_camera,- principal_camera_id=self.principal_camera_id,- image_sizes=self.image_sizes),-- )-- def error_function(self,- current_guess: list[float],- camera_intrinsics: dict[CameraIdString, CameraIntrinsicsEstimate],- image_points_by_camera: dict[CameraIdString, ImagePoints2D],- principal_camera_id: CameraIdString,- image_sizes: dict[CameraIdString, tuple[int, int]]- ) -> list[float]:-- # reform 'current_guess' into camera extrinsics matricies- camera_ids = list(self.camera_intrinsics.keys())- camera_transforms: dict[CameraIdString, TransformationMatrix] = {}- camera_extrinsics: dict[CameraIdString, CameraExtrinsicsMatrix] = {}- undistored_image_points: dict[CameraIdString, ImagePoints2D] = {}- for camera_index, camera_id in enumerate(camera_ids):- # split the 1d vector by camera based on `self.number_of_parameters_per_camera`- starting_index = camera_index * self.number_of_parameters_per_camera- ending_index = (camera_index + 1) * self.number_of_parameters_per_camera- camera_transforms[camera_id] = TransformationMatrix.from_extrinsics(- extrinsics_matrix=np.array(current_guess[starting_index:ending_index]).reshape(3, 4),- reference_frame=f"camera-{principal_camera_id}")- camera_extrinsics[camera_id] = camera_transforms[camera_id].extrinsics_matrix- # undistort the image points for each camera using the camera intrinsics- undistored_image_points[camera_id] = undistort_points(- points2d=np.asarray(image_points_by_camera[camera_id]),- camera_intrinsics=camera_intrinsics[camera_id])- # re-scale from normalized image coordinates to pixel coordinates- # undistored_image_points[camera_id][:, 0] *= image_sizes[camera_id][0]- # undistored_image_points[camera_id][:, 1] *= image_sizes[camera_id][1]- # triangulate 3D points from 2D points using camera extrinsics and intrinsics (provided as kwargs)- points3d = []- for point_index in range(self.number_of_points):- # triangulate the 3D point from the 2D points- image_point_by_camera = {camera_id: undistored_image_points[camera_id][point_index]- for camera_id in camera_ids}- points3d.append(triangulate_point(image_point_by_camera=image_point_by_camera,- camera_extrinsics=camera_extrinsics))-- # calculate reprojection error for each point- reprojection_error_by_point, _ = calculate_reprojection_error(object_points=np.asarray(points3d),- image_points_by_camera=undistored_image_points,- camera_transforms=camera_transforms,- camera_intrinsics=camera_intrinsics,- image_sizes=image_sizes)-- return np.mean(reprojection_error_by_point)-- def get_jacobian_sparse_matrix(self) -> dok_matrix:- jacobian_matrix = np.ones((self.number_of_points, self.number_of_optimization_parameters))-- # TODO - Implement the logic to populate the jacobian_matrix based on the current guess and image points- # basically for each row (point2d) on the jacobian matrix, we need to populate the columns (parameters) that are affected by that point- # so the parameters for the camea that can't see each point should be zero-- for point_index in range(self.number_of_points):- row_values = []- num_cams_that_can_see_point = 0- for camera_id, image_points in self.image_points_by_camera.items():- if np.isnan(image_points[point_index][0]) or np.isnan(image_points[point_index][1]):- row_values.append(np.zeros(self.number_of_parameters_per_camera))- else:- num_cams_that_can_see_point += 1- row_values.append(np.ones(self.number_of_parameters_per_camera))- if num_cams_that_can_see_point < 2:- row_values = [np.zeros(self.number_of_parameters_per_camera) for _ in range(len(row_values))]- jacobian_matrix[point_index] = np.concatenate(row_values)-- return dok_matrix(jacobian_matrix).tocsr()diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/multi_camera_calibrator.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/multi_camera_calibrator.pydeleted file mode 100644index 28b5dcaf..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/multi_camera_calibrator.py+++ /dev/null@@ -1,470 +0,0 @@-import logging--import cv2-import numpy as np-from pydantic import BaseModel-from skellycam.core.types.type_overloads import CameraIdString--from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.camera_math_models import (- TransformationMatrix,- RotationVector,- TranslationVector,-)-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.single_camera_calibrator import (- CameraIntrinsicsEstimate,- SingleCameraCalibrator,-)-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.pyceres_bundle_adjuster import PyCeresBundleAdjuster-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.scipy_bundle_adjuster import ScipyBundleAdjuster-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.shared_view_accumulator import (- SharedViewAccumulator,- CameraPair,-)-from freemocap.pubsub.pubsub_topics import CameraNodeOutputMessage--logger = logging.getLogger(__name__)---class MultiCameraCalibrationEstimate(BaseModel):- principal_camera_id: CameraIdString- camera_transforms_by_camera_id: dict[CameraIdString, TransformationMatrix]---class MultiCameraCalibrator(BaseModel):- principal_camera_id: CameraIdString- camera_id_to_index: dict[CameraIdString, int]- multi_cam_output_accumulator: SharedViewAccumulator-- single_camera_calibrators: dict[CameraIdString, SingleCameraCalibrator] | None = None- multi_camera_calibration_estimate: MultiCameraCalibrationEstimate | None = None- bundle_adjuster: ScipyBundleAdjuster | PyCeresBundleAdjuster | None = None- minimum_views_to_reconstruct: int | None = 100-- @classmethod- def from_camera_ids(- cls,- camera_ids: list[CameraIdString],- principal_camera_id: CameraIdString | None = None,- ) -> "MultiCameraCalibrator":- return cls(- principal_camera_id=principal_camera_id if principal_camera_id is not None else min(camera_ids),- camera_id_to_index={camera_id: index for index, camera_id in enumerate(camera_ids)},- multi_cam_output_accumulator=SharedViewAccumulator.create(camera_ids=camera_ids),- )-- @property- def has_calibration(self) -> bool:- if self.single_camera_calibrators is None or self.multi_camera_calibration_estimate is None:- return False- return all(- single_camera_calibrator.has_calibration- for single_camera_calibrator in self.single_camera_calibrators.values()- ) and self.multi_camera_calibration_estimate is not None-- @property- def camera_intrinsics(self) -> dict[CameraIdString, CameraIntrinsicsEstimate]:- if self.single_camera_calibrators is None:- raise ValueError("Single camera calibrators not initialized")- return {- camera_id: single_camera_calibrator.camera_intrinsics_estimate- for camera_id, single_camera_calibrator in self.single_camera_calibrators.items()- }-- @property- def ready_to_calibrate(self) -> bool:- if not self.single_camera_calibrators:- return False- return self.all_cameras_have_min_shared_views()-- def receive_camera_node_output(- self,- multi_frame_number: int,- camera_node_output_by_camera: dict[CameraIdString, CameraNodeOutputMessage],- ) -> None:- # Log multi-camera output- self.multi_cam_output_accumulator.receive_camera_node_output(- multi_frame_number=multi_frame_number,- camera_node_output_by_camera=camera_node_output_by_camera,- )-- # Add views to single camera calibrators- if self.single_camera_calibrators is None:- self.initialize_single_camera_calibrators(camera_node_output_by_camera=camera_node_output_by_camera)-- for camera_id, calibrator in self.single_camera_calibrators.items():- obs = camera_node_output_by_camera[camera_id].observation- if obs and obs.charuco_board_visible:- calibrator.add_observation(observation=obs)-- def initialize_single_camera_calibrators(- self,- camera_node_output_by_camera: dict[CameraIdString, CameraNodeOutputMessage],- ) -> None:- logger.info(f"Initializing single camera calibrators for {len(camera_node_output_by_camera)} cameras")- self.single_camera_calibrators = {}-- for camera_id, node_output in camera_node_output_by_camera.items():- logger.debug(f"Creating calibrator for camera {camera_id}")- self.single_camera_calibrators[camera_id] = SingleCameraCalibrator.create_initial(- camera_id=camera_id,- image_size=node_output.observation.image_size,- all_aruco_marker_ids=node_output.observation.all_aruco_ids,- all_aruco_corners_in_object_coordinates=node_output.observation.all_aruco_corners_in_object_coordinates,- all_charuco_corner_ids=node_output.observation.all_charuco_ids,- all_charuco_corners_in_object_coordinates=node_output.observation.all_charuco_corners_in_object_coordinates,- )-- def all_cameras_have_min_shared_views(self) -> bool:- if self.minimum_views_to_reconstruct is None:- raise ValueError("minimum_views_to_reconstruct is not set")- return self.multi_cam_output_accumulator.all_cameras_have_min_shared_views(- min_shared_views=self.minimum_views_to_reconstruct- )-- def calibrate(self) -> MultiCameraCalibrationEstimate:- """Calibrate multi-camera system using OpenCV's stereoCalibrate."""- if self.single_camera_calibrators is None:- raise ValueError("Single camera calibrators not initialized")-- logger.info(f"Starting multi-camera calibration for cameras: {list(self.single_camera_calibrators.keys())}")- logger.info(f"Principal camera: {self.principal_camera_id}")- shared_view_counts = self.multi_cam_output_accumulator.get_shared_view_count_per_camera()- logger.info(f"Shared view counts: {shared_view_counts}")-- # Step 1: Calibrate each camera individually- logger.info("=" * 80)- logger.info("STEP 1: Individual camera calibration")- logger.info("=" * 80)- for calibrator in self.single_camera_calibrators.values():- logger.info(f"Calibrating camera {calibrator.camera_id}...")- calibrator.calibrate()- logger.info(- f"Camera {calibrator.camera_id} calibration complete: "- f"reprojection error = {calibrator.mean_reprojection_error:.3f} pixels"- )-- # Step 2: Compute stereo calibration for each camera pair- logger.info("=" * 80)- logger.info("STEP 2: Stereo calibration for camera pairs")- logger.info("=" * 80)- camera_pair_transforms = self._calculate_camera_pair_transforms_with_stereo_calibrate()-- # Step 3: Build transforms to principal camera- logger.info("=" * 80)- logger.info("STEP 3: Computing transforms to principal camera")- logger.info("=" * 80)- camera_transforms = self._calculate_camera_to_principal_camera_transforms(- camera_pair_secondary_camera_transform_estimates=camera_pair_transforms- )-- self.multi_camera_calibration_estimate = MultiCameraCalibrationEstimate(- principal_camera_id=self.principal_camera_id,- camera_transforms_by_camera_id=camera_transforms,- )-- logger.success(- "Initial multi-camera calibration complete. "- "Use run_bundle_adjustment() for optional refinement."- )-- return self.multi_camera_calibration_estimate-- def run_bundle_adjustment(self) -> MultiCameraCalibrationEstimate:- """Refine calibration using scipy bundle adjustment."""- if self.multi_camera_calibration_estimate is None:- raise ValueError("Must run calibrate() first before bundle adjustment")-- if self.single_camera_calibrators is None:- raise ValueError("No single camera calibrators available")-- logger.info("=" * 80)- logger.info("BUNDLE ADJUSTMENT REFINEMENT")- logger.info("=" * 80)-- # Get camera intrinsics- camera_intrinsics = {}- for camera_id, calibrator in self.single_camera_calibrators.items():- camera_intrinsics[camera_id] = (- calibrator.camera_matrix,- calibrator.distortion_coefficients,- )- logger.debug(- f"Camera {camera_id} intrinsics: "- f"fx={calibrator.camera_matrix.focal_length_x:.2f}, "- f"fy={calibrator.camera_matrix.focal_length_y:.2f}"- )-- # Get charuco corners in world coordinates- first_calibrator = next(iter(self.single_camera_calibrators.values()))- charuco_corners_3d = first_calibrator.all_charuco_corners_in_object_coordinates- logger.info(f"Using {len(charuco_corners_3d)} charuco corners as 3D reference points")-- # Create bundle adjuster- logger.info("Creating scipy bundle adjuster...")- self.bundle_adjuster = ScipyBundleAdjuster.create(- principal_camera_id=self.principal_camera_id,- camera_transforms=self.multi_camera_calibration_estimate.camera_transforms_by_camera_id,- camera_intrinsics=camera_intrinsics,- charuco_corners_3d=charuco_corners_3d,- )-- # Get multi-camera views- multi_camera_views = self.multi_cam_output_accumulator.multi_camera_views_by_frame- logger.info(f"Running optimization on {len(multi_camera_views)} multi-camera views...")-- # Run optimization- optimized_transforms = self.bundle_adjuster.optimize(multi_camera_views=multi_camera_views)-- # Update estimate- self.multi_camera_calibration_estimate = MultiCameraCalibrationEstimate(- principal_camera_id=self.principal_camera_id,- camera_transforms_by_camera_id=optimized_transforms,- )-- logger.success("Bundle adjustment complete!")- return self.multi_camera_calibration_estimate-- def _calculate_camera_pair_transforms_with_stereo_calibrate(- self,- ) -> dict[CameraPair, TransformationMatrix]:- """Calculate camera pair transforms using OpenCV's stereoCalibrate."""- if self.single_camera_calibrators is None:- raise ValueError("Single camera calibrators not initialized")-- camera_pair_transforms = {}-- for base_camera_id, shared_views_dict in self.multi_cam_output_accumulator.camera_shared_views.items():- for camera_pair, shared_views in shared_views_dict.items():- if camera_pair in camera_pair_transforms:- logger.debug(f"Skipping already-calculated pair: {camera_pair}")- continue-- base_camera_id = camera_pair.base_camera_id- other_camera_id = camera_pair.other_camera_id-- logger.info(f"Computing stereo calibration: {base_camera_id} ↔ {other_camera_id}")- logger.debug(f" Using {len(shared_views)} shared views")-- # Extract matched observations- object_points_list = []- base_image_points_list = []- other_image_points_list = []-- for view in shared_views:- base_obs = view.base_camera_observation- other_obs = view.other_camera_observation-- # Find common corner IDs between the two observations- base_corner_ids = set(base_obs.detected_charuco_corner_ids)- other_corner_ids = set(other_obs.detected_charuco_corner_ids)- common_corner_ids = base_corner_ids & other_corner_ids-- if len(common_corner_ids) < 6:- logger.debug(- f" Skipping frame {view.multi_frame_number}: "- f"only {len(common_corner_ids)} common corners"- )- continue-- # Build matched point arrays- common_corner_ids_sorted = sorted(common_corner_ids)-- object_points = []- base_image_points = []- other_image_points = []-- for corner_id in common_corner_ids_sorted:- # Get 3D object point- object_points.append(- self.single_camera_calibrators[base_camera_id]- .all_charuco_corners_in_object_coordinates[corner_id]- )-- # Get 2D image points- base_idx = np.where(base_obs.detected_charuco_corner_ids == corner_id)[0][0]- other_idx = np.where(other_obs.detected_charuco_corner_ids == corner_id)[0][0]-- base_image_points.append(base_obs.detected_charuco_corners_image_coordinates[base_idx])- other_image_points.append(other_obs.detected_charuco_corners_image_coordinates[other_idx])-- object_points_list.append(np.array(object_points, dtype=np.float32))- base_image_points_list.append(np.array(base_image_points, dtype=np.float32))- other_image_points_list.append(np.array(other_image_points, dtype=np.float32))-- if len(object_points_list) < 10:- raise ValueError(- f"Insufficient matched views for stereo calibration between "- f"{base_camera_id} and {other_camera_id}: only {len(object_points_list)} views"- )-- logger.info(f" Using {len(object_points_list)} matched views for stereo calibration")-- # Get intrinsics- base_calibrator = self.single_camera_calibrators[base_camera_id]- other_calibrator = self.single_camera_calibrators[other_camera_id]-- # Run stereoCalibrate- logger.debug(" Running cv2.stereoCalibrate...")- (- rms_error,- camera_matrix_1,- dist_coeffs_1,- camera_matrix_2,- dist_coeffs_2,- R,- T,- E,- F,- ) = cv2.stereoCalibrate(- objectPoints=object_points_list,- imagePoints1=base_image_points_list,- imagePoints2=other_image_points_list,- cameraMatrix1=base_calibrator.camera_matrix.matrix.copy(),- distCoeffs1=base_calibrator.distortion_coefficients.coefficients.copy(),- cameraMatrix2=other_calibrator.camera_matrix.matrix.copy(),- distCoeffs2=other_calibrator.distortion_coefficients.coefficients.copy(),- imageSize=base_calibrator.image_size,- flags=cv2.CALIB_FIX_INTRINSIC, # Don't re-optimize intrinsics- criteria=(cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100, 1e-6),- )-- logger.info(f" Stereo calibration RMS error: {rms_error:.4f} pixels")- logger.debug(f" Rotation matrix norm: {np.linalg.norm(R):.4f}")- logger.debug(f" Translation vector norm: {np.linalg.norm(T):.4f}")-- # Convert R, T to TransformationMatrix (other_camera -> base_camera)- rotation_vector = RotationVector(- vector=np.squeeze(cv2.Rodrigues(R)[0]),- reference_frame=f"camera-{base_camera_id}",- )- translation_vector = TranslationVector(- vector=np.squeeze(T),- reference_frame=f"camera-{base_camera_id}",- )-- transform = TransformationMatrix.from_rotation_translation(- rotation_vector=rotation_vector,- translation_vector=translation_vector,- )-- camera_pair_transforms[camera_pair] = transform- logger.debug(f" Transform computed successfully")-- logger.info(f"Computed {len(camera_pair_transforms)} stereo calibrations")- return camera_pair_transforms-- def _calculate_camera_to_principal_camera_transforms(- self,- camera_pair_secondary_camera_transform_estimates: dict[CameraPair, TransformationMatrix],- ) -> dict[CameraIdString, TransformationMatrix]:- """Build transforms from all cameras to principal camera using pairwise transforms."""- if self.single_camera_calibrators is None:- raise ValueError("Single camera calibrators not initialized")-- # Start with principal camera at identity- transform_to_principal_camera_by_camera = {- self.principal_camera_id: TransformationMatrix(- matrix=np.eye(4, dtype=np.float64),- reference_frame=f"camera-{self.principal_camera_id}",- )- }-- # Initialize other cameras as None- for camera_id in self.single_camera_calibrators.keys():- if camera_id != self.principal_camera_id:- transform_to_principal_camera_by_camera[camera_id] = None-- logger.info(f"Building transform graph from principal camera: {self.principal_camera_id}")-- # Iteratively resolve transforms using available pairs- iteration = 0- while any(transform is None for transform in transform_to_principal_camera_by_camera.values()):- iteration += 1- unresolved = [- camera_id- for camera_id, transform in transform_to_principal_camera_by_camera.items()- if transform is None- ]- logger.debug(f"Iteration {iteration}: {len(unresolved)} unresolved cameras: {unresolved}")-- progress_made = False-- for camera_pair, pair_transform in camera_pair_secondary_camera_transform_estimates.items():- base_id = camera_pair.base_camera_id- other_id = camera_pair.other_camera_id-- # Skip if other camera already resolved- if transform_to_principal_camera_by_camera[other_id] is not None:- continue-- # Case 1: base is principal camera- if base_id == self.principal_camera_id:- logger.debug(f" Resolved {other_id} directly from principal camera")- transform_to_principal_camera_by_camera[other_id] = pair_transform- progress_made = True-- # Case 2: other is principal camera- elif other_id == self.principal_camera_id:- logger.debug(f" Resolved {base_id} as inverse from principal camera")- transform_to_principal_camera_by_camera[base_id] = pair_transform.get_inverse()- progress_made = True-- # Case 3: base is resolved, other is not- elif transform_to_principal_camera_by_camera[base_id] is not None:- base_to_principal = transform_to_principal_camera_by_camera[base_id]- logger.debug(f" Resolved {other_id} via {base_id}")- transform_to_principal_camera_by_camera[other_id] = base_to_principal @ pair_transform- progress_made = True-- # Case 4: other is resolved, base is not- elif transform_to_principal_camera_by_camera[other_id] is not None:- other_to_principal = transform_to_principal_camera_by_camera[other_id]- logger.debug(f" Resolved {base_id} via {other_id} (inverse)")- transform_to_principal_camera_by_camera[base_id] = (- other_to_principal @ pair_transform.get_inverse()- )- progress_made = True-- if not progress_made:- unresolved_cameras = [- cid for cid, t in transform_to_principal_camera_by_camera.items() if t is None- ]- raise RuntimeError(- f"Cannot resolve transforms for cameras {unresolved_cameras}. "- f"Camera network may not be fully connected to principal camera."- )-- logger.success(f"All camera transforms resolved in {iteration} iterations")-- # Log final transforms- for camera_id, transform in transform_to_principal_camera_by_camera.items():- if camera_id == self.principal_camera_id:- logger.info(f" Camera {camera_id}: [Principal camera - identity]")- else:- t = transform.translation_vector.vector- logger.info(- f" Camera {camera_id}: translation=[{t[0]:.3f}, {t[1]:.3f}, {t[2]:.3f}]"- )-- return transform_to_principal_camera_by_camera---if __name__ == "__main__":- import pickle- from pathlib import Path-- pickle_path = r"C:\Users\jonma\github_repos\freemocap_organization\freemocap\freemocap\saved_mc_calib.pkl"- if not Path(pickle_path).exists():- raise FileNotFoundError(f"File not found: {pickle_path}")-- logger.info(f"Loading calibrator from: {pickle_path}")- loaded: MultiCameraCalibrator = pickle.load(open(pickle_path, "rb"))-- # Run calibration- logger.info("Starting calibration process...")- loaded.calibrate()-- logger.info("Running bundle adjustment refinement...")- refined_estimate = loaded.run_bundle_adjustment()-- logger.success("Calibration pipeline complete!")diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/positional_6dof.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/positional_6dof.pydeleted file mode 100644index e0e60d59..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/positional_6dof.py+++ /dev/null@@ -1,39 +0,0 @@-import cv2-import numpy as np-from numpydantic import NDArray, Shape-from pydantic import BaseModel--from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.calibration_numpy_types import \- TransformationMatrixArray, TranslationVectorArray, RotationVectorArray---class Positional6DoF(BaseModel):- translation: TranslationVectorArray = np.zeros(3)- rotation: RotationVectorArray = np.zeros(3)-- @property- def transformation_matrix(self) -> TransformationMatrixArray:- return self.get_transformation_matrix()-- def get_transformation_matrix(self, return_jacobian: bool = False) -> TransformationMatrixArray | tuple[- TransformationMatrixArray, NDArray[Shape['3, 9'], np.float32]]:- """- Returns the transformation matrix for this 6DoF pose in the form of a 4x4 matrix (homogeneous coordinates)- the left upper 3x3 matrix is the rotation matrix, and the rightmost column is the translation vector.- the bottom row is [0, 0, 0, 1] (where the 1 is the homogeneous coordinate, which makes the matrix invertible and provides the scale factor for the translation vector to put it in spatial coordinates)- """-- transformation_matrix = np.zeros((4, 4))-- transformation_matrix[:3, :3], jacobian = cv2.Rodrigues(self.rotation)- transformation_matrix[:3, 3] = self.translation.flatten()- transformation_matrix[3, 3] = 1- if return_jacobian:- return transformation_matrix, jacobian- return transformation_matrix---if __name__ == "__main__":- positional_6dof = Positional6DoF()- print(positional_6dof.transformation_matrix)- print(positional_6dof.model_dump_json(indent=2))diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/single_camera_calibration_estimate.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/single_camera_calibration_estimate.pydeleted file mode 100644index fc7dc313..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/single_camera_calibration_estimate.py+++ /dev/null@@ -1,32 +0,0 @@-from pydantic import BaseModel-from pydantic import Field-from skellycam.core.types.type_overloads import CameraIdString--from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.calibration_numpy_types import \- TransformationMatrixArray, CameraMatrixArray, CameraDistortionCoefficientsArray-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.positional_6dof import Positional6DoF---class SingleCameraCalibrationEstimate(BaseModel):- camera_id: CameraIdString-- camera_matrix: CameraMatrixArray- distortion_coefficients: CameraDistortionCoefficientsArray-- positional_6dof: Positional6DoF = Field(default_factory=Positional6DoF)-- @property- def focal_length(self):- fx = self.camera_matrix[0, 0]- fy = self.camera_matrix[1, 1]- return (fx + fy) / 2.0-- @focal_length.setter- def focal_length(self, fx: float, fy: float = None):- if fy is None:- fy = fx- self.camera_matrix[0, 0] = fx- self.camera_matrix[1, 1] = fy-- def extrinsic_matrix(self) -> TransformationMatrixArray:- return self.positional_6dof.transformation_matrixdiff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/single_camera_calibrator.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/single_camera_calibrator.pydeleted file mode 100644index 178cb462..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/single_camera_calibrator.py+++ /dev/null@@ -1,538 +0,0 @@-import logging--import cv2-import numpy as np-from pydantic import BaseModel, Field-from skellycam.core.types.type_overloads import CameraIdString-from skellytracker.trackers.charuco_tracker.charuco_observation import (- CharucoObservations,- CharucoObservation,- AllCharucoCorners3DByIdInObjectCoordinates,- AllArucoCorners3DByIdInObjectCoordinates,-)--from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.calibration_numpy_types import (- ObjectPoints3D,- ImagePoints2D,-)-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.camera_math_models import (- RotationVector,- TranslationVector,- TransformationMatrix,- CameraDistortionCoefficients,- CameraMatrix,-)-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.charuco_view_optimizer import (- CharucoViewOptimizer,- CharucoViewSelectionConfig,-)--logger = logging.getLogger(__name__)--DEFAULT_INTRINSICS_COEFFICIENTS_COUNT = 4-MIN_CHARUCO_CORNERS = 6-MIN_OBSERVATIONS_TO_CALIBRATE = 100-DEFAULT_TARGET_VIEW_COUNT = 25-INITIAL_VIEW_COUNT = 25---class CameraIntrinsicsEstimate(BaseModel):- camera_id: CameraIdString- camera_matrix: CameraMatrix- distortion_coefficients: CameraDistortionCoefficients---class SingleCameraCalibrator(BaseModel):- """- SingleCameraCalibrator class for estimating camera calibration parameters.-- This calibrator stores ALL observations but can calibrate using a subset.- The subset is determined by frame_numbers passed to update_calibration_estimate().- """-- camera_id: CameraIdString- image_size: tuple[int, ...]-- all_charuco_corner_ids: list[int]- all_charuco_corners_in_object_coordinates: AllCharucoCorners3DByIdInObjectCoordinates-- all_aruco_marker_ids: list[int]- all_aruco_corners_in_object_coordinates: AllArucoCorners3DByIdInObjectCoordinates-- distortion_coefficients: CameraDistortionCoefficients- camera_matrix: CameraMatrix-- # Store ALL observations - never modified by optimization- charuco_observations: CharucoObservations = Field(default_factory=CharucoObservations)-- # Calibration results - updated by update_calibration_estimate()- board_rotation_vectors: list[RotationVector] = []- board_translation_vectors: list[TranslationVector] = []- reprojection_error_per_point_by_view: list[list[float]] = []- reprojection_error_by_view: list[float] = []- mean_reprojection_error: float | None = None- camera_calibration_residual: float | None = None-- # Selected frame number for single-camera calibration (optimized coverage and diversity)- selected_frame_numbers: list[int] = []-- @property- def camera_intrinsics_estimate(self) -> CameraIntrinsicsEstimate:- return CameraIntrinsicsEstimate(- camera_id=self.camera_id,- camera_matrix=self.camera_matrix,- distortion_coefficients=self.distortion_coefficients,- )-- @property- def has_calibration(self) -> bool:- return self.mean_reprojection_error is not None-- @property- def ready_to_calibrate(self) -> bool:- return len(self.charuco_observations) >= MIN_OBSERVATIONS_TO_CALIBRATE-- @property- def charuco_transformation_matrices(self) -> list[TransformationMatrix]:- return [- TransformationMatrix.from_rotation_translation(- rotation_vector=rotation_vector,- translation_vector=translation_vector,- )- for rotation_vector, translation_vector in zip(- self.board_rotation_vectors, self.board_translation_vectors- )- ]-- @classmethod- def from_charuco_observations(- cls,- camera_id: CameraIdString,- charuco_observations: CharucoObservations):- calibrator = cls.from_charuco_observation(camera_id=camera_id,- charuco_observation=charuco_observations[0])- for observation in charuco_observations[1:]:- calibrator.add_observation(observation=observation)- return calibrator-- @classmethod- def from_charuco_observation(- cls,- camera_id: CameraIdString,- charuco_observation: CharucoObservation):-- return cls.create_initial(- camera_id=camera_id,- image_size=charuco_observation.image_size,- all_aruco_marker_ids=charuco_observation.all_aruco_ids,- all_aruco_corners_in_object_coordinates=charuco_observation.all_aruco_corners_in_object_coordinates,- all_charuco_corner_ids=charuco_observation.all_charuco_ids,- all_charuco_corners_in_object_coordinates=charuco_observation.all_charuco_corners_in_object_coordinates,- )-- @classmethod- def create_initial(- cls,- camera_id: CameraIdString,- image_size: tuple[int, ...],- all_aruco_marker_ids: list[int],- all_aruco_corners_in_object_coordinates: AllArucoCorners3DByIdInObjectCoordinates,- all_charuco_corner_ids: list[int],- all_charuco_corners_in_object_coordinates: AllCharucoCorners3DByIdInObjectCoordinates,- number_of_distortion_coefficients: int = DEFAULT_INTRINSICS_COEFFICIENTS_COUNT,- ) -> "SingleCameraCalibrator":-- if len(all_charuco_corner_ids) != all_charuco_corners_in_object_coordinates.shape[0]:- raise ValueError(- "Number of charuco corner IDs must match the number of charuco corners."- )- if len(all_aruco_marker_ids) != len(all_aruco_corners_in_object_coordinates):- raise ValueError(- "Number of aruco marker IDs must match the number of aruco corners."- )-- return cls(- camera_id=camera_id,- image_size=image_size,- all_charuco_corner_ids=all_charuco_corner_ids,- all_charuco_corners_in_object_coordinates=all_charuco_corners_in_object_coordinates,- all_aruco_marker_ids=all_aruco_marker_ids,- all_aruco_corners_in_object_coordinates=all_aruco_corners_in_object_coordinates,- camera_matrix=CameraMatrix.from_image_size(image_size=image_size),- distortion_coefficients=CameraDistortionCoefficients(- coefficients=np.zeros(number_of_distortion_coefficients)- ),- )-- def add_observation(self, observation: CharucoObservation) -> None:- if observation.frame_number in [obs.frame_number for obs in self.charuco_observations]:- return- if observation.charuco_empty or len(observation.detected_charuco_corner_ids) < MIN_CHARUCO_CORNERS:- return- self._validate_observation(observation=observation)-- self.charuco_observations.append(observation)-- def calibrate(self) -> None:- """- Calibrate single-camera intrinsics using optimized subset of observations.-- """- logger.info(f"Calibrating camera {self.camera_id} with {len(self.charuco_observations)} observations...")-- self.selected_frame_numbers = self.select_optimal_frame_numbers()-- logger.info(f"Calibrating camera {self.camera_id} with {len(self.selected_frame_numbers)} optimized views...")- self.update_calibration_estimate(frame_numbers=self.selected_frame_numbers,- store_results_in_state=True)-- logger.success(- f"Camera {self.camera_id} calibration complete! "- f"Calibration error: {self.mean_reprojection_error:.3f} pixels"- )-- def select_optimal_frame_numbers(- self,- target_count: int = DEFAULT_TARGET_VIEW_COUNT,- initial_count: int = DEFAULT_TARGET_VIEW_COUNT,- ) -> list[int]:- """- Select optimal frame numbers for calibration without modifying stored observations.-- Uses two-stage optimization:- 1. Spatial optimization → quick calibration → pose estimation- 2. Pose-based optimization → return optimal frame numbers-- Args:- target_count: Final number of views to select- initial_count: Initial views for bootstrapping-- Returns:- List of frame numbers to use for calibration- """- if len(self.charuco_observations) == 0:- raise ValueError("No observations to optimize")-- original_count = len(self.charuco_observations)-- if original_count <= target_count:- logger.info(- f"Camera {self.camera_id}: Have {original_count} views, no optimization needed"- )- return [obs.frame_number for obs in self.charuco_observations]-- logger.info(- f"Camera {self.camera_id}: Optimizing {original_count} views → {target_count} views"- )-- # STAGE 1: Select initial views spatially- config = CharucoViewSelectionConfig(- initial_view_count=initial_count,- target_view_count=target_count,- )- optimizer = CharucoViewOptimizer(- image_size=(int(self.image_size[0]), int(self.image_size[1])),- config=config,- )-- initial_indices = optimizer.select_initial_views(observations=self.charuco_observations)- initial_frame_numbers = [self.charuco_observations[i].frame_number for i in initial_indices]-- logger.info(f"Camera {self.camera_id}: Selected {len(initial_frame_numbers)} initial views, calibrating...")-- # Quick calibration for pose estimation- (residual,- camera_matrix,- distortion_coefficients,- rotation_vectors,- translation_vectors- ) = self.update_calibration_estimate(frame_numbers=initial_frame_numbers, store_results_in_state=False)-- # STAGE 2: Estimate poses for ALL observations- logger.info(f"Camera {self.camera_id}: Estimating poses for all {original_count} observations...")-- all_rvecs = []- all_tvecs = []-- for obs in self.charuco_observations:- if obs.charuco_empty or len(obs.detected_charuco_corner_ids) < MIN_CHARUCO_CORNERS:- all_rvecs.append(np.zeros(3, dtype=np.float32))- all_tvecs.append(np.zeros(3, dtype=np.float32))- continue-- object_points = self.all_charuco_corners_in_object_coordinates[- np.squeeze(obs.detected_charuco_corner_ids), :- ]- image_points = np.squeeze(obs.detected_charuco_corners_image_coordinates)-- try:- success, rvec, tvec = cv2.solvePnP(- objectPoints=object_points,- imagePoints=image_points,- cameraMatrix=camera_matrix,- distCoeffs=distortion_coefficients,- )- if not success:- raise ValueError(f"solvePnP failed for frame {obs.frame_number}")-- all_rvecs.append(np.squeeze(rvec))- all_tvecs.append(np.squeeze(tvec))- except (cv2.error, ValueError) as e:- raise RuntimeError(f"Failed to estimate pose for frame {obs.frame_number}: {e}")-- # Select final views using pose information- final_indices = optimizer.select_final_views(- observations=self.charuco_observations,- rotation_vectors=all_rvecs,- translation_vectors=all_tvecs,- )-- final_frame_numbers = [self.charuco_observations[i].frame_number for i in final_indices]-- logger.info(- f"Camera {self.camera_id}: Optimization complete - "- f"selected {len(final_frame_numbers)} final views"- )-- return final_frame_numbers-- def update_calibration_estimate(- self,- frame_numbers: list[int] | None = None,- store_results_in_state: bool = True # if false, don't update internal state- ) -> tuple[float, np.ndarray, np.ndarray, list[RotationVector], list[TranslationVector]]:- """- Update calibration estimate using specified frame numbers.-- If frame_numbers is None, uses ALL observations.-- Args:- frame_numbers: Specific frame numbers to use for calibration.- If None, uses all available observations.- """- # Select observations to use- if frame_numbers is None:- observations_to_use = self.charuco_observations- logger.info(f"Calibrating camera {self.camera_id} with ALL {len(observations_to_use)} observations")- else:- frame_number_set = set(frame_numbers)- observations_to_use = [- obs for obs in self.charuco_observations- if obs.frame_number in frame_number_set- ]-- if len(observations_to_use) != len(frame_numbers):- raise ValueError(- f"Requested {len(frame_numbers)} frame numbers but only found "- f"{len(observations_to_use)} matching observations"- )-- logger.debug(f"Calibrating camera {self.camera_id} with {len(observations_to_use)} selected views...")-- # Build object and image points from selected observations- object_points_views: list[ObjectPoints3D] = []- image_points_views: list[ImagePoints2D] = []-- for obs in observations_to_use:- image_points_views.append(np.squeeze(obs.detected_charuco_corners_image_coordinates))- object_points_views.append(- self.all_charuco_corners_in_object_coordinates[- np.squeeze(obs.detected_charuco_corner_ids), :- ]- )-- if len(object_points_views) < len(self.all_charuco_corner_ids):- raise ValueError(- f"Need at least {len(self.all_charuco_corner_ids)} observations, "- f"have {len(object_points_views)}"- )-- view_count = len(object_points_views)-- if view_count > 50 and frame_numbers is None:- logger.warning(- f"Camera {self.camera_id}: Using {view_count} views without optimization. "- f"Consider calling select_optimal_frame_numbers() first."- )-- # Run OpenCV calibration- (- camera_calibration_residual,- camera_matrix_output,- distortion_coefficients_output,- rotation_vectors_output,- translation_vectors_output,- ) = cv2.calibrateCamera(- objectPoints=object_points_views,- imagePoints=image_points_views,- imageSize=self.image_size,- cameraMatrix=self.camera_matrix.matrix,- distCoeffs=self.distortion_coefficients.coefficients,- )-- if not camera_calibration_residual:- raise ValueError("Camera calibration failed! Check input data.")-- # Store results- board_rotation_vectors = [- RotationVector(- vector=np.squeeze(rotation_vector),- reference_frame=f"camera-{self.camera_id}",- )- for rotation_vector in rotation_vectors_output- ]- board_translation_vectors = [- TranslationVector(- vector=np.squeeze(translation_vector),- reference_frame=f"camera-{self.camera_id}",- )- for translation_vector in translation_vectors_output- ]-- logger.debug(- f"Camera {self.camera_id} calibration complete! "- f"Residual: {camera_calibration_residual:.4f}"- )-- if store_results_in_state:- self.camera_calibration_residual = camera_calibration_residual- self.camera_matrix = CameraMatrix(matrix=camera_matrix_output)- self.distortion_coefficients = CameraDistortionCoefficients(- coefficients=np.squeeze(distortion_coefficients_output)- )- self.board_rotation_vectors = board_rotation_vectors- self.board_translation_vectors = board_translation_vectors- self._update_reprojection_error(- object_points_views=object_points_views,- image_points_views=image_points_views,- )- return camera_calibration_residual, camera_matrix_output, distortion_coefficients_output, board_rotation_vectors, board_translation_vectors-- def get_board_pose(- self,- object_points: np.ndarray,- image_points: np.ndarray- ) -> tuple[np.ndarray, np.ndarray]:- """- Estimate board pose from object and image points.-- Args:- object_points: Nx3 array of 3D points- image_points: Nx2 array of 2D points-- Returns:- Tuple of (rotation_vector, translation_vector)- """- if len(object_points) < 6:- raise ValueError("Need at least 6 object points to estimate board pose")- if not self.has_calibration:- raise ValueError("Must calibrate camera first")- if len(object_points) != len(image_points):- raise ValueError("Object and image points must have same length")-- success, rotation_vector, translation_vector = cv2.solvePnP(- objectPoints=object_points,- imagePoints=image_points,- cameraMatrix=self.camera_matrix.matrix,- distCoeffs=self.distortion_coefficients.coefficients,- )-- if not success:- raise ValueError("Failed to estimate board pose")-- return rotation_vector, translation_vector-- def draw_board_axes(- self,- image: np.ndarray,- observation: CharucoObservation- ) -> np.ndarray:- """- Draw 3D axes on the board in the image.-- Args:- image: Image to draw on- observation: Observation containing board detection-- Returns:- Image with axes drawn- """- if not self.has_calibration:- raise ValueError("Must calibrate camera first")- if observation.detected_charuco_corners_image_coordinates.shape[0] < 6:- return image-- rotation_vector, translation_vector = self.get_board_pose(- object_points=observation.detected_charuco_corners_in_object_coordinates,- image_points=observation.detected_charuco_corners_image_coordinates,- )-- axis_length = 5- return cv2.drawFrameAxes(- image,- self.camera_matrix.matrix,- self.distortion_coefficients.coefficients,- rotation_vector,- translation_vector,- axis_length,- )-- def _validate_observation(self, observation: CharucoObservation) -> None:- """Validate observation matches calibrator configuration."""- if observation.image_size != self.image_size:- raise ValueError(- f"Image size mismatch: expected {self.image_size}, got {observation.image_size}"- )- if any(- corner_id not in self.all_charuco_corner_ids- for corner_id in observation.detected_charuco_corner_ids- ):- raise ValueError(- f"Invalid charuco corner ID detected: {observation.detected_charuco_corner_ids}"- )-- def _update_reprojection_error(- self,- object_points_views: list[ObjectPoints3D],- image_points_views: list[ImagePoints2D],- ) -> None:- """Compute reprojection error for calibrated views."""- if len(image_points_views) != len(object_points_views):- raise ValueError("Image and object points must have same length")- if len(image_points_views) == 0:- raise ValueError("No image points provided")- if len(image_points_views) != len(self.board_rotation_vectors):- raise ValueError(- f"Number of views ({len(image_points_views)}) must match "- f"number of rotation vectors ({len(self.board_rotation_vectors)})"- )-- self.reprojection_error_per_point_by_view = []- self.reprojection_error_by_view = []-- for view_index in range(len(image_points_views)):- projected_image_points, jacobian = cv2.projectPoints(- objectPoints=object_points_views[view_index],- rvec=self.board_rotation_vectors[view_index].vector,- tvec=self.board_translation_vectors[view_index].vector,- cameraMatrix=self.camera_matrix.matrix,- distCoeffs=self.distortion_coefficients.coefficients,- aspectRatio=self.image_size[0] / self.image_size[1],- )-- self.reprojection_error_per_point_by_view.append(- np.abs(- image_points_views[view_index]- - np.squeeze(projected_image_points)- )- )-- self.reprojection_error_by_view.append(- float(np.nanmean(self.reprojection_error_per_point_by_view[-1]))- )-- self.mean_reprojection_error = float(np.nanmean(self.reprojection_error_by_view))-- logger.debug(- f"Camera {self.camera_id} - Mean reprojection error: {self.mean_reprojection_error:.3f} pixels"- )diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/triangulate_points.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/triangulate_points.pydeleted file mode 100644index 77ea73db..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/triangulate_points.py+++ /dev/null@@ -1,122 +0,0 @@-import cv2-import numpy as np-from skellycam.core.types.type_overloads import CameraIdString--from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.calibration_numpy_types import ObjectPoint3D, \- ImagePoints2D, ObjectPoints3D, ReprojectionError, CameraExtrinsicsMatrix, ImagePoint2D-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.camera_math_models import TransformationMatrix-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.single_camera_calibrator import \- CameraIntrinsicsEstimate---def undistort_points(points2d: ImagePoints2D,- camera_intrinsics: CameraIntrinsicsEstimate) -> ImagePoints2D:- """- Undistorts 2D points using the camera's intrinsic parameters and distortion coefficients.-- This function adjusts the provided 2D points to account for lens distortion, returning- points that are mapped as they would appear in an ideal pinhole camera model. The process- ensures (or attempts to ensure) that the ray passing from the nodal point of the camera lens through the- undistorted 2D point intersects the corresponding 3D point in space accurately.-- :param points2d: A NumPy array of shape (N, 2) representing the 2D points- to be undistorted, where N is the number of 2d points. These are typically the distorted- pixel coordinates captured by the camera.- :return: A NumPy array of the same shape as `points2d` containing the undistorted 2D points (in normalized image coordinates, I think?).- """- undistorted_points2d = cv2.undistortPoints(src=points2d,- cameraMatrix=camera_intrinsics.camera_matrix.matrix,- distCoeffs=camera_intrinsics.distortion_coefficients.coefficients,- )-- return np.squeeze(undistorted_points2d)---# @jit(nopython=True, parallel=False)-def triangulate_point(image_point_by_camera: dict[CameraIdString, ImagePoint2D],- camera_extrinsics: dict[CameraIdString, CameraExtrinsicsMatrix]) -> ObjectPoint3D:- _validate_triangulation_input(camera_extrinsics=camera_extrinsics,- image_point_by_camera=image_point_by_camera)- camera_ids = list(camera_extrinsics.keys())- number_of_cameras = len(camera_ids)- A = np.zeros((number_of_cameras * 2,- 4)) # SVD needs this to be a 2d array of shape (2n, 4), where n is the number of cameras- for camera_number, camera_id in enumerate(camera_ids):- image_points_x = image_point_by_camera[camera_id][0]- image_points_y = image_point_by_camera[camera_id][1]- camera_matrix = camera_extrinsics[camera_id]- A[(camera_number * 2): (camera_number * 2 + 1)] = image_points_x * camera_matrix[2] - camera_matrix[0]- A[(camera_number * 2 + 1): (camera_number * 2 + 2)] = image_points_y * camera_matrix[2] - camera_matrix[1]- u, s, vh = np.linalg.svd(A,- full_matrices=True) # SVD returns the singular values in descending order, so the last row of vh is the solution (i.e. the 3D point represented in homogeneous coordinates)- points_3d = vh[-1]- points_3d = points_3d[:3] / points_3d[3]- return points_3d---def _validate_triangulation_input(camera_extrinsics: dict[CameraIdString, CameraExtrinsicsMatrix],- image_point_by_camera: dict[CameraIdString, ImagePoint2D]):- if len(image_point_by_camera) < 2:- raise ValueError("Need at least two cameras to triangulate points.")- if image_point_by_camera.keys() != camera_extrinsics.keys():- raise ValueError("Camera IDs in image_point_by_camera and camera_extrinsics must match.")- if not all([image_point_by_camera[camera_id].shape == (2,) for camera_id in image_point_by_camera.keys()]):- raise ValueError("All image points must be 2D points.")- if not all([camera_extrinsics[camera_id].shape == (3, 4) for camera_id in camera_extrinsics.keys()]):- raise ValueError("All camera extrinsics must be 3x4 matrices.")---def _validate_reprojection_error_input(object_points: ObjectPoints3D,- image_points_by_camera: dict[CameraIdString, ImagePoints2D],- camera_intrinsics: dict[CameraIdString, CameraIntrinsicsEstimate],- camera_transforms: dict[CameraIdString, TransformationMatrix],- image_sizes: dict[CameraIdString, tuple[int, int]]):- if len(image_points_by_camera) < 2:- raise ValueError("Need at least two cameras to triangulate points.")- if any([image_sizes.keys() != camera_intrinsics.keys(),- image_sizes.keys() != camera_transforms.keys(),- image_sizes.keys() != image_points_by_camera.keys()]):- raise ValueError("Camera IDs in image_points_by_camera, camera_intrinsics, and camera_transforms must match.")- for camera_id in image_points_by_camera.keys():- if not all([point.shape == (2,) for point in image_points_by_camera[camera_id]]):- raise ValueError("All image points must be 2D points.")---# @jit(nopython=True, parallel=False)-def calculate_reprojection_error(object_points: ObjectPoints3D,- image_points_by_camera: dict[CameraIdString, ImagePoints2D],- camera_intrinsics: dict[CameraIdString, CameraIntrinsicsEstimate],- camera_transforms: dict[CameraIdString, TransformationMatrix],- image_sizes: dict[CameraIdString, tuple[int, int]]) -> tuple[- list[ReprojectionError], dict[CameraIdString, list[ReprojectionError]]]:- # https://docs.opencv.org/4.10.0/d9/d0c/group__calib3d.html#ga1019495a2c8d1743ed5cc23fa0daff8c- _validate_reprojection_error_input(object_points=object_points,- image_points_by_camera=image_points_by_camera,- camera_intrinsics=camera_intrinsics,- camera_transforms=camera_transforms,- image_sizes=image_sizes)- reprojection_error_per_point_by_camera: dict[CameraIdString, list[ReprojectionError]] = {}- for camera_id in camera_intrinsics.keys():- projected_image_points, jacobian = cv2.projectPoints(objectPoints=object_points,- rvec=camera_transforms[camera_id].rotation_vector.vector,- tvec=camera_transforms[- camera_id].translation_vector.vector,- cameraMatrix=camera_intrinsics[- camera_id].camera_matrix.matrix,- distCoeffs=camera_intrinsics[- camera_id].distortion_coefficients.coefficients,- aspectRatio=image_sizes[camera_id][0] /- image_sizes[camera_id][1]- )-- reprojection_error_per_point_by_camera[camera_id] = np.abs(- image_points_by_camera[camera_id] - np.squeeze(projected_image_points))-- mean_reprojection_error_per_point = []- for point_index in range(len(object_points)):- point_reprojection_error = []- for camera_id in camera_intrinsics.keys():- point_reprojection_error.append(reprojection_error_per_point_by_camera[camera_id][point_index])- mean_reprojection_error_per_point.append(float(np.nanmean(point_reprojection_error)))-- return mean_reprojection_error_per_point, reprojection_error_per_point_by_cameradiff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/create_triangulator_from_multicam_calibrator.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/create_triangulator_from_multicam_calibrator.pydeleted file mode 100644index bc656a36..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/create_triangulator_from_multicam_calibrator.py+++ /dev/null@@ -1,113 +0,0 @@-import logging--import cv2-import numpy as np-from skellycam.core.types.type_overloads import CameraIdString--from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.multi_camera_calibrator import \- MultiCameraCalibrator-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.point_triangulator import PointTriangulator, CameraCalibrationData-from freemocap.pubsub.pubsub_topics import CameraNodeOutputMessage--logger = logging.getLogger(__name__)---def create_triangulator_from_calibrator(- multi_camera_calibrator: MultiCameraCalibrator-) -> PointTriangulator:- """- Convert MultiCameraCalibrator calibration results into PointTriangulator format.-- :param multi_camera_calibrator: Calibrated multi-camera system- :return: Initialized PointTriangulator ready for fast triangulation- :raises ValueError: If calibrator doesn't have calibration data- """- if not multi_camera_calibrator.has_calibration:- raise ValueError(- "MultiCameraCalibrator must be calibrated before creating triangulator. "- "Call calibrate() first."- )-- camera_calibrations: dict[str, CameraCalibrationData] = {}-- for camera_id, single_camera_calibrator in multi_camera_calibrator.single_camera_calibrators.items():- # Get intrinsics from single camera calibrator- intrinsics = single_camera_calibrator.camera_intrinsics_estimate- camera_matrix = intrinsics.camera_matrix- distortion_coeffs = intrinsics.distortion_coefficients-- # Get extrinsics from multi-camera calibration estimate- transform = multi_camera_calibrator.multi_camera_calibration_estimate.camera_transforms_by_camera_id[camera_id]- extrinsics = transform.extrinsics_matrix-- # Extract rotation vector and translation from extrinsics matrix [R|t]- rotation_matrix = extrinsics[:3, :3]- translation_vector = extrinsics[:3, 3]- rotation_vector = cv2.Rodrigues(rotation_matrix)[0].ravel()-- # Get image size- image_size = single_camera_calibrator.image_size-- # Create CameraCalibrationData- camera_calibrations[camera_id] = CameraCalibrationData(- name=camera_id,- image_size=image_size,- matrix=camera_matrix,- distortion=distortion_coeffs,- rotation_vector=rotation_vector,- translation=translation_vector- )-- return PointTriangulator(camera_calibrations=camera_calibrations)---def triangulate_list(- triangulator: PointTriangulator,- camera_node_outputs_stream: list[dict[CameraIdString, CameraNodeOutputMessage]],- undistort_points: bool = True,- compute_reprojection_error: bool = False-) -> tuple[np.ndarray, np.ndarray | None]:- """- Efficiently triangulate a stream of multi-camera observations.-- :param triangulator: Initialized PointTriangulator- :param camera_node_outputs_stream: List of frame observations across cameras- :param undistort_points: Whether to undistort points before triangulation- :param compute_reprojection_error: Whether to compute reprojection errors- :return: Tuple of (all_points3d, all_errors)- - all_points3d: Shape (F, M, 3) - F frames, M charuco corners, 3D coords- - all_errors: Shape (F, M) - reprojection errors per point per frame, or None- :raises ValueError: If stream is empty or cameras missing- """- if not camera_node_outputs_stream:- raise ValueError("camera_node_outputs_stream cannot be empty")-- num_frames = len(camera_node_outputs_stream)-- # Get number of charuco corners from first valid observation- first_frame = camera_node_outputs_stream[0]- first_camera_output = next(iter(first_frame.values()))- num_corners = first_camera_output.observation.to_2d_array().shape[0]-- # Pre-allocate output arrays- all_points3d = np.empty((num_frames, num_corners, 3), dtype=np.float64)- all_errors = np.empty((num_frames, num_corners), dtype=np.float64) if compute_reprojection_error else None-- # Process each frame- for frame_idx, camera_node_outputs in enumerate(camera_node_outputs_stream):- try:- points3d, errors = triangulator.triangulate_camera_node_outputs(- camera_node_outputs=camera_node_outputs,- undistort_points=undistort_points,- compute_reprojection_error=compute_reprojection_error- )-- all_points3d[frame_idx] = points3d- if compute_reprojection_error and errors is not None:- all_errors[frame_idx] = errors-- except ValueError as e:- logger.error(f"Triangulation failed for frame {frame_idx}: {e}")- raise-- return all_points3d, all_errorsdiff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/og_v1_capture_volume_calibration/__init__.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/og_v1_capture_volume_calibration/__init__.pydeleted file mode 100644index e69de29b..00000000diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/pyceres_bundle_adjuster.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/pyceres_bundle_adjuster.pydeleted file mode 100644index 6e82b78e..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/pyceres_bundle_adjuster.py+++ /dev/null@@ -1,275 +0,0 @@-import logging--import cv2-import numpy as np-import pyceres-from pydantic import BaseModel, Field-from scipy.spatial.transform import Rotation-from skellycam.core.types.type_overloads import CameraIdString--from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.camera_math_models import (- CameraMatrix,- CameraDistortionCoefficients,- TransformationMatrix,-)-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.shared_view_accumulator import MultiCameraTargetView--logger = logging.getLogger(__name__)---class ReprojectionCost(pyceres.CostFunction):- def __init__(- self,- observed_point: np.ndarray,- point_3d: np.ndarray,- fx: float,- fy: float,- cx: float,- cy: float,- ) -> None:- super().__init__()- self.observed_point = observed_point.astype(np.float64).copy()- self.point_3d = point_3d.astype(np.float64).copy()- self.fx = fx- self.fy = fy- self.cx = cx- self.cy = cy-- self.set_num_residuals(2)- # Separate rvec and tvec like the working code separates quat and trans!- self.set_parameter_block_sizes([3, 3])-- def Evaluate(- self,- parameters: list[np.ndarray],- residuals: np.ndarray,- jacobians: list[np.ndarray] | None,- ) -> bool:- rvec = parameters[0]- tvec = parameters[1]-- # Convert rotation vector to rotation matrix- angle = np.linalg.norm(rvec)- if angle < 1e-10:- R = np.eye(3, dtype=np.float64)- else:- R = Rotation.from_rotvec(rvec).as_matrix()-- # Transform 3D point to camera coordinates- X_cam = R @ self.point_3d + tvec-- # Check for points behind camera- if X_cam[2] < 1e-6:- residuals[0] = 1000.0- residuals[1] = 1000.0- return True-- # Project to normalized image coordinates (no distortion for now)- x = X_cam[0] / X_cam[2]- y = X_cam[1] / X_cam[2]-- # Apply camera matrix- u = self.fx * x + self.cx- v = self.fy * y + self.cy-- # Compute residuals- residuals[0] = u - self.observed_point[0]- residuals[1] = v - self.observed_point[1]-- return True---class CameraParameters(BaseModel):- camera_id: CameraIdString- extrinsics: np.ndarray = Field(default_factory=lambda: np.zeros(6, dtype=np.float64))- intrinsics: np.ndarray = Field(default_factory=lambda: np.zeros(9, dtype=np.float64))-- class Config:- arbitrary_types_allowed = True-- @classmethod- def from_calibration_data(- cls,- camera_id: CameraIdString,- rotation_vector: np.ndarray,- translation_vector: np.ndarray,- camera_matrix: CameraMatrix,- distortion_coeffs: CameraDistortionCoefficients,- ) -> "CameraParameters":- extrinsics = np.zeros(6, dtype=np.float64)- extrinsics[0:3] = rotation_vector.flatten()- extrinsics[3:6] = translation_vector.flatten()-- intrinsics = np.zeros(9, dtype=np.float64)- intrinsics[0] = camera_matrix.focal_length_x- intrinsics[1] = camera_matrix.focal_length_y- intrinsics[2], intrinsics[3] = camera_matrix.principal_point-- dist = distortion_coeffs.coefficients if hasattr(distortion_coeffs, "coefficients") else distortion_coeffs- num_dist = min(len(dist), 5)- intrinsics[4: 4 + num_dist] = dist[0:num_dist]-- return cls(camera_id=camera_id, extrinsics=extrinsics, intrinsics=intrinsics)-- def to_transformation_matrix(self, reference_frame: str) -> TransformationMatrix:- rotation_matrix = cv2.Rodrigues(self.extrinsics[0:3])[0]- matrix = np.eye(4, dtype=np.float64)- matrix[0:3, 0:3] = rotation_matrix- matrix[0:3, 3] = self.extrinsics[3:6]- return TransformationMatrix(matrix=matrix, reference_frame=reference_frame)-- def to_camera_matrix(self) -> np.ndarray:- matrix = np.eye(3, dtype=np.float64)- matrix[0, 0] = self.intrinsics[0]- matrix[1, 1] = self.intrinsics[1]- matrix[0, 2] = self.intrinsics[2]- matrix[1, 2] = self.intrinsics[3]- return matrix-- def to_distortion_coefficients(self) -> np.ndarray:- return self.intrinsics[4:9]---class PyCeresBundleAdjuster(BaseModel):- principal_camera_id: CameraIdString- camera_parameters: dict[CameraIdString, CameraParameters] = Field(default_factory=dict)- point_3d_coords: dict[int, np.ndarray] = Field(default_factory=dict)-- class Config:- arbitrary_types_allowed = True-- @classmethod- def create(- cls,- principal_camera_id: CameraIdString,- camera_transforms: dict[CameraIdString, TransformationMatrix],- camera_intrinsics: dict[CameraIdString, tuple[CameraMatrix, CameraDistortionCoefficients]],- charuco_corners_3d: np.ndarray,- ) -> "PyCeresBundleAdjuster":- camera_parameters = {}- for camera_id, transform in camera_transforms.items():- camera_matrix, dist_coeffs = camera_intrinsics[camera_id]- rotation_vector = cv2.Rodrigues(transform.rotation_matrix)[0].flatten()- translation = transform.translation_vector.vector.flatten()- camera_parameters[camera_id] = CameraParameters.from_calibration_data(- camera_id=camera_id,- rotation_vector=rotation_vector,- translation_vector=translation,- camera_matrix=camera_matrix,- distortion_coeffs=dist_coeffs,- )-- point_3d_coords = {i: charuco_corners_3d[i].astype(np.float64).copy() for i in range(len(charuco_corners_3d))}- return cls(- principal_camera_id=principal_camera_id,- camera_parameters=camera_parameters,- point_3d_coords=point_3d_coords,- )-- def optimize(- self,- multi_camera_views: dict[int, MultiCameraTargetView],- ) -> dict[CameraIdString, TransformationMatrix]:- logger.info("Starting PyCeres bundle adjustment optimization (FIXED STRUCTURE)...")-- # FOLLOW THE WORKING CODE'S PATTERN EXACTLY- # 1. Create separate arrays for rotation and translation (like quat and trans)- camera_ids = sorted(self.camera_parameters.keys())-- # Store rotation and translation SEPARATELY like the working code- rvecs: list[np.ndarray] = []- tvecs: list[np.ndarray] = []- rvec_by_id: dict[CameraIdString, np.ndarray] = {}- tvec_by_id: dict[CameraIdString, np.ndarray] = {}-- for camera_id in camera_ids:- params = self.camera_parameters[camera_id]- rvec = np.array(params.extrinsics[0:3], dtype=np.float64, order='C')- tvec = np.array(params.extrinsics[3:6], dtype=np.float64, order='C')- rvecs.append(rvec)- tvecs.append(tvec)- rvec_by_id[camera_id] = rvec- tvec_by_id[camera_id] = tvec-- # Keep all cost functions alive- cost_functions: list[ReprojectionCost] = []-- problem = pyceres.Problem()-- # Add parameter blocks separately like the working code- for camera_id in camera_ids:- problem.add_parameter_block(rvec_by_id[camera_id], 3)- problem.add_parameter_block(tvec_by_id[camera_id], 3)-- # Fix the principal camera- problem.set_parameter_block_constant(rvec_by_id[self.principal_camera_id])- problem.set_parameter_block_constant(tvec_by_id[self.principal_camera_id])-- # Add residual blocks- residual_count = 0- for mc_view in multi_camera_views.values():- for camera_id, camera_output in mc_view.camera_node_output_by_camera.items():- if not camera_output.observation or camera_output.observation.charuco_empty:- continue-- obs = camera_output.observation- params = self.camera_parameters[camera_id]- camera_matrix = params.to_camera_matrix()-- fx = float(camera_matrix[0, 0])- fy = float(camera_matrix[1, 1])- cx = float(camera_matrix[0, 2])- cy = float(camera_matrix[1, 2])-- rvec = rvec_by_id[camera_id]- tvec = tvec_by_id[camera_id]-- for corner_idx, corner_id in enumerate(obs.detected_charuco_corner_ids):- corner_id_int = int(corner_id)- if corner_id_int not in self.point_3d_coords:- continue-- cost = ReprojectionCost(- observed_point=obs.detected_charuco_corners_image_coordinates[corner_idx],- point_3d=self.point_3d_coords[corner_id_int],- fx=fx,- fy=fy,- cx=cx,- cy=cy,- )- cost_functions.append(cost)- # Pass BOTH parameter blocks like the working code!- problem.add_residual_block(cost, None, [rvec, tvec])- residual_count += 1-- logger.info(f"Added {residual_count} reprojection residuals")- logger.info(f"Total parameter blocks: {problem.num_parameters()}")- logger.info(f"Total residual blocks: {problem.num_residual_blocks()}")-- # Configure solver - match the working code exactly- options = pyceres.SolverOptions()- options.max_num_iterations = 100- options.minimizer_progress_to_stdout = True- options.linear_solver_type = pyceres.LinearSolverType.SPARSE_NORMAL_CHOLESKY- options.function_tolerance = 1e-9 # Match working code- options.gradient_tolerance = 1e-11 # Match working code- options.parameter_tolerance = 1e-10 # Match working code-- # Solve- summary = pyceres.SolverSummary()- pyceres.solve(options, problem, summary)-- logger.info(f"Optimization complete: Cost {summary.initial_cost:.2f} -> {summary.final_cost:.2f}")- logger.info(f"Iterations: {summary.num_successful_steps}")- logger.info(f"Termination: {summary.termination_type}")-- # Copy optimized values back- for camera_id in camera_ids:- self.camera_parameters[camera_id].extrinsics[0:3] = rvec_by_id[camera_id]- self.camera_parameters[camera_id].extrinsics[3:6] = tvec_by_id[camera_id]-- # Return optimized transforms- return {- cid: params.to_transformation_matrix(reference_frame=f"camera-{self.principal_camera_id}")- for cid, params in self.camera_parameters.items()- }diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/scipy_bundle_adjuster.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/scipy_bundle_adjuster.pydeleted file mode 100644index 4c10385f..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/scipy_bundle_adjuster.py+++ /dev/null@@ -1,227 +0,0 @@-import logging--import cv2-import numpy as np-from pydantic import BaseModel, Field-from scipy.optimize import least_squares-from skellycam.core.types.type_overloads import CameraIdString--from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.camera_math_models import (- CameraMatrix,- CameraDistortionCoefficients,- TransformationMatrix,-)-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.shared_view_accumulator import MultiCameraTargetView--logger = logging.getLogger(__name__)---class CameraParameters(BaseModel):- camera_id: CameraIdString- extrinsics: np.ndarray = Field(default_factory=lambda: np.zeros(6, dtype=np.float64))- intrinsics: np.ndarray = Field(default_factory=lambda: np.zeros(9, dtype=np.float64))-- class Config:- arbitrary_types_allowed = True-- @classmethod- def from_calibration_data(- cls,- camera_id: CameraIdString,- rotation_vector: np.ndarray,- translation_vector: np.ndarray,- camera_matrix: CameraMatrix,- distortion_coeffs: CameraDistortionCoefficients,- ) -> "CameraParameters":- extrinsics = np.zeros(6, dtype=np.float64)- extrinsics[0:3] = rotation_vector.flatten()- extrinsics[3:6] = translation_vector.flatten()-- intrinsics = np.zeros(9, dtype=np.float64)- intrinsics[0] = camera_matrix.focal_length_x- intrinsics[1] = camera_matrix.focal_length_y- intrinsics[2], intrinsics[3] = camera_matrix.principal_point-- dist = distortion_coeffs.coefficients if hasattr(distortion_coeffs, "coefficients") else distortion_coeffs- num_dist = min(len(dist), 5)- intrinsics[4: 4 + num_dist] = dist[0:num_dist]-- return cls(camera_id=camera_id, extrinsics=extrinsics, intrinsics=intrinsics)-- def to_transformation_matrix(self, reference_frame: str) -> TransformationMatrix:- rotation_matrix = cv2.Rodrigues(self.extrinsics[0:3])[0]- matrix = np.eye(4, dtype=np.float64)- matrix[0:3, 0:3] = rotation_matrix- matrix[0:3, 3] = self.extrinsics[3:6]- return TransformationMatrix(matrix=matrix, reference_frame=reference_frame)-- def to_camera_matrix(self) -> np.ndarray:- matrix = np.eye(3, dtype=np.float64)- matrix[0, 0] = self.intrinsics[0]- matrix[1, 1] = self.intrinsics[1]- matrix[0, 2] = self.intrinsics[2]- matrix[1, 2] = self.intrinsics[3]- return matrix-- def to_distortion_coefficients(self) -> np.ndarray:- return self.intrinsics[4:9]---class ScipyBundleAdjuster(BaseModel):- principal_camera_id: CameraIdString- camera_parameters: dict[CameraIdString, CameraParameters] = Field(default_factory=dict)- point_3d_coords: dict[int, np.ndarray] = Field(default_factory=dict)-- class Config:- arbitrary_types_allowed = True-- @classmethod- def create(- cls,- principal_camera_id: CameraIdString,- camera_transforms: dict[CameraIdString, TransformationMatrix],- camera_intrinsics: dict[CameraIdString, tuple[CameraMatrix, CameraDistortionCoefficients]],- charuco_corners_3d: np.ndarray,- ) -> "ScipyBundleAdjuster":- camera_parameters = {}- for camera_id, transform in camera_transforms.items():- camera_matrix, dist_coeffs = camera_intrinsics[camera_id]- rotation_vector = cv2.Rodrigues(transform.rotation_matrix)[0].flatten()- translation = transform.translation_vector.vector.flatten()- camera_parameters[camera_id] = CameraParameters.from_calibration_data(- camera_id=camera_id,- rotation_vector=rotation_vector,- translation_vector=translation,- camera_matrix=camera_matrix,- distortion_coeffs=dist_coeffs,- )-- point_3d_coords = {i: charuco_corners_3d[i].astype(np.float64).copy() for i in range(len(charuco_corners_3d))}- return cls(- principal_camera_id=principal_camera_id,- camera_parameters=camera_parameters,- point_3d_coords=point_3d_coords,- )-- def _pack_parameters(self, camera_ids: list[CameraIdString],- extrinsics_by_id: dict[CameraIdString, np.ndarray]) -> np.ndarray:- """Pack all camera extrinsics into a single parameter vector."""- params = []- for camera_id in camera_ids:- if camera_id != self.principal_camera_id: # Don't include fixed camera- params.append(extrinsics_by_id[camera_id])- return np.concatenate(params) if params else np.array([])-- def _unpack_parameters(self, params: np.ndarray, camera_ids: list[CameraIdString]) -> dict[- CameraIdString, np.ndarray]:- """Unpack parameter vector into camera extrinsics."""- extrinsics_by_id = {}- idx = 0- for camera_id in camera_ids:- if camera_id == self.principal_camera_id:- # Principal camera is fixed- extrinsics_by_id[camera_id] = self.camera_parameters[camera_id].extrinsics.copy()- else:- extrinsics_by_id[camera_id] = params[idx:idx + 6]- idx += 6- return extrinsics_by_id-- def _compute_residuals(- self,- params: np.ndarray,- camera_ids: list[CameraIdString],- intrinsics_by_id: dict[CameraIdString, tuple[np.ndarray, np.ndarray]],- multi_camera_views: dict[int, MultiCameraTargetView],- ) -> np.ndarray:- """Compute reprojection residuals for all observations."""- extrinsics_by_id = self._unpack_parameters(params, camera_ids)- residuals = []-- for mc_view in multi_camera_views.values():- for camera_id, camera_output in mc_view.camera_node_output_by_camera.items():- if not camera_output.observation or camera_output.observation.charuco_empty:- continue-- obs = camera_output.observation- camera_matrix, dist_coeffs = intrinsics_by_id[camera_id]- rvec = extrinsics_by_id[camera_id][0:3]- tvec = extrinsics_by_id[camera_id][3:6]-- for corner_idx, corner_id in enumerate(obs.detected_charuco_corner_ids):- corner_id_int = int(corner_id)- if corner_id_int not in self.point_3d_coords:- continue-- # Project point- projected, _ = cv2.projectPoints(- objectPoints=self.point_3d_coords[corner_id_int].reshape(1, 3),- rvec=rvec.reshape(3, 1),- tvec=tvec.reshape(3, 1),- cameraMatrix=camera_matrix,- distCoeffs=dist_coeffs,- )-- # Compute residual- observed = obs.detected_charuco_corners_image_coordinates[corner_idx]- residuals.append(projected.squeeze()[0] - observed[0])- residuals.append(projected.squeeze()[1] - observed[1])-- return np.array(residuals)-- def optimize(- self,- multi_camera_views: dict[int, MultiCameraTargetView],- ) -> dict[CameraIdString, TransformationMatrix]:- logger.info("Starting scipy bundle adjustment optimization...")-- # Extract parameters- camera_ids = list(self.camera_parameters.keys())- extrinsics_by_id: dict[CameraIdString, np.ndarray] = {}- intrinsics_by_id: dict[CameraIdString, tuple[np.ndarray, np.ndarray]] = {}-- for camera_id in camera_ids:- params = self.camera_parameters[camera_id]- extrinsics_by_id[camera_id] = params.extrinsics.copy()- camera_matrix = params.to_camera_matrix()- dist_coeffs = params.to_distortion_coefficients()- intrinsics_by_id[camera_id] = (camera_matrix, dist_coeffs)-- # Pack initial parameters- x0 = self._pack_parameters(camera_ids, extrinsics_by_id)-- # Compute initial residuals- initial_residuals = self._compute_residuals(x0, camera_ids, intrinsics_by_id, multi_camera_views)- initial_cost = 0.5 * np.sum(initial_residuals ** 2)- num_residuals = len(initial_residuals)-- logger.info(f"Initial cost: {initial_cost:.2f} ({num_residuals} residuals)")-- # Run optimization- result = least_squares(- fun=lambda params: self._compute_residuals(params, camera_ids, intrinsics_by_id, multi_camera_views),- x0=x0,- method='trf', # Trust Region Reflective - robust and good for large residual problems- verbose=2,- max_nfev=100, # Max function evaluations- ftol=1e-6,- gtol=1e-10,- xtol=1e-8,- )-- final_cost = 0.5 * np.sum(result.fun ** 2)- logger.info(f"Optimization complete: Cost {initial_cost:.2f} -> {final_cost:.2f}")- logger.info(f"Success: {result.success}, Message: {result.message}")- logger.info(f"Function evaluations: {result.nfev}")-- # Unpack optimized parameters- optimized_extrinsics = self._unpack_parameters(result.x, camera_ids)-- # Update camera parameters- for camera_id in camera_ids:- self.camera_parameters[camera_id].extrinsics[:] = optimized_extrinsics[camera_id]-- # Return optimized transforms- return {- cid: params.to_transformation_matrix(reference_frame=f"camera-{self.principal_camera_id}")- for cid, params in self.camera_parameters.items()- }diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/__init__.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/__init__.pydeleted file mode 100644index e69de29b..00000000diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/anipose_camera_calibration/__init__.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/anipose_camera_calibration/__init__.pydeleted file mode 100644index e69de29b..00000000diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/anipose_camera_calibration/anipose_camera_calibrator.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/anipose_camera_calibration/anipose_camera_calibrator.pydeleted file mode 100644index 84ead59d..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/anipose_camera_calibration/anipose_camera_calibrator.py+++ /dev/null@@ -1,300 +0,0 @@-import logging-from collections import namedtuple-from dataclasses import dataclass-from pathlib import Path-from typing import Callable, Union--import cv2-import numpy as np--from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.v1_capture_volume_calibration.anipose_camera_calibration import \- freemocap_anipose-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.charuco_groundplane_utils import \- skellyforge_data, find_good_frame, CharucoVisibilityError, compute_basis_vectors_of_new_reference, \- CharucoVelocityError-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.v1_capture_volume_calibration.charuco_stuff.charuco_board_definition import \- CharucoBoardDefinition-from freemocap.utilities.get_video_paths import get_video_paths--logger = logging.getLogger(__name__)--Extrinsics = namedtuple("Extrinsics", ["rvecs", "tvecs"])---@dataclass-class GroundPlaneSuccess:- success: bool- error: str = None---class AniposeCameraCalibrator:- def __init__(- self,- charuco_board_object: CharucoBoardDefinition,- charuco_square_size: Union[int, float],- calibration_recording_folder: Union[str, Path],- progress_callback: Callable[[str], None] = lambda _: None-- ):- self._charuco_board_object = charuco_board_object- self._progress_callback = progress_callback-- if charuco_square_size == 1:- warning_string = "Charuco square size is not set, so units of 3d reconstructed data will be in units of `however_long_the_black_edge_of_the_charuco_square_was`. Please input `charuco_square_size` in millimeters (or your preferred unity of length)"- logger.warning(warning_string)- self._progress_callback(warning_string)- self._charuco_square_size = charuco_square_size- self._recording_folder_path = Path(calibration_recording_folder)-- self._calibration_videos_folder_path = self._recording_folder_path / "synchronized_videos"- self._get_video_paths()- self._initialize_anipose_objects()-- @property- def calibration_toml_path(self) -> Path:- recording_name = self._recording_folder_path.stem- toml_name = f"{recording_name}_camera_calibration.toml"- return self._recording_folder_path / toml_name-- def _get_video_paths(self):- self._list_of_video_paths = get_video_paths(path_to_video_folder=Path(self._calibration_videos_folder_path))- if len(self._list_of_video_paths) == 0:- error_message = f"No calibration videos found in folder: {str(self._calibration_videos_folder_path)}"- logger.error(error_message)- raise ValueError(error_message)- if len(self._list_of_video_paths) < 2:- error_message = f"At least two calibration videos are required for camera calibration, but only {len(self._list_of_video_paths)} video(s) were found in folder: {str(self._calibration_videos_folder_path)}"- logger.error(error_message)- raise ValueError(error_message)-- def _initialize_anipose_objects(self):- list_of_camera_names = [this_video_path.stem for this_video_path in self._list_of_video_paths]- self._anipose_camera_group_object = freemocap_anipose.CameraGroup.from_names(list_of_camera_names)-- # add metadata- self._anipose_camera_group_object.metadata["charuco_square_size"] = self._charuco_square_size- self._anipose_camera_group_object.metadata["charuco_board_object"] = str(self._charuco_board_object)- self._anipose_camera_group_object.metadata["path_to_recorded_videos"] = str(- self._calibration_videos_folder_path- )- self._anipose_camera_group_object.metadata["date_time_calibrated"] = str(np.datetime64("now"))-- self._anipose_charuco_board = freemocap_anipose.AniposeCharucoBoard(- self._charuco_board_object.number_of_squares_width,- self._charuco_board_object.number_of_squares_height,- square_length=self._charuco_square_size, # mm- marker_length=self._charuco_square_size * 0.8,- marker_bits=4,- dict_size=50,- )-- def calibrate_camera_capture_volume(self,- pin_camera_0_to_origin: bool = False,- use_charuco_as_groundplane: bool = False) -> tuple[Path, GroundPlaneSuccess]:- video_paths_list_of_list_of_strings = [[str(this_path)] for this_path in self._list_of_video_paths]-- self._anipose_camera_group_object.calibrate_videos(- video_paths_list_of_list_of_strings, self._anipose_charuco_board- )- success_str = "Anipose Calibration Successful!"- logger.info(success_str)- self._progress_callback(success_str)- self._anipose_camera_group_object.metadata["groundplane_calibration"] = False-- if pin_camera_0_to_origin:- self._anipose_camera_group_object = self.pin_camera_zero_to_origin(self._anipose_camera_group_object)- groundplane_success = None-- if use_charuco_as_groundplane:- self._anipose_camera_group_object, groundplane_success = self.set_charuco_board_as_groundplane(- self._anipose_camera_group_object)- if groundplane_success.success:- self._anipose_camera_group_object.metadata["groundplane_calibration"] = True-- self.get_real_world_matrices(self._anipose_camera_group_object)-- self._anipose_camera_group_object.dump(self.calibration_toml_path)- logger.debug(- f"anipose camera calibration data saved tor - {str(self.calibration_toml_path)}"- )-- def pin_camera_zero_to_origin(self, cam_group: freemocap_anipose.CameraGroup):- """- Re-express all camera extrinsics relative to camera 0.-- This function performs two operations:- 1. Rotates all camera coordinate systems so that camera 0's orientation becomes the new world frame.- 2. Shifts the world origin to camera 0's position, making it the new coordinate origin (0, 0, 0).-- The result is that:- - Camera 0 ends up with an identity rotation and zero translation.- - All other cameras are expressed relative to camera 0's original position and orientation.-- Args:- cam_group (freemocap_anipose.CameraGroup): A group of calibrated cameras whose extrinsics will be adjusted in place.- """-- rvecs_new = self.align_rotations_to_cam0(cam_group=cam_group)- cam_group.set_rotations(rvecs_new)- tvecs_new = self.shift_origin_to_cam0(cam_group=cam_group)- cam_group.set_translations(tvecs_new)- return cam_group-- def align_rotations_to_cam0(self, cam_group: freemocap_anipose.CameraGroup):- rvecs = cam_group.get_rotations()- # get rotation of cam 0 to world- R0, _ = cv2.Rodrigues(rvecs[0])-- rvecs_new = np.empty_like(rvecs)- # rotates each cameras coordinate system into the new world space- # R0 maps world -> cam0, so R0.T (which is also the inverse) maps cam0 -> world- # R0 * R0^-1 = identity matrix, so this makes R0 the origin- # then we map every other camera into the new world space- for i in range(rvecs.shape[0]):- Ri, _ = cv2.Rodrigues(rvecs[i])- Ri_new, _ = cv2.Rodrigues(Ri @ R0.T)- rvecs_new[i] = Ri_new.flatten()- return rvecs_new-- def shift_origin_to_cam0(self, cam_group: freemocap_anipose.CameraGroup):- # Get original translation and rotation vectors- tvecs = cam_group.get_translations()- rvecs = cam_group.get_rotations()-- # Extract camera 0's rotation and translation- camera_0_translation = tvecs[0, :]- camera_0_rotation = rvecs[0, :]-- # Get 3x3 rotation matrix for world -> cam 0- R0, _ = cv2.Rodrigues(camera_0_rotation)-- # Get the vector that moves the world origin to cam 0 in the world frame- delta_to_origin_world = - R0.T @ camera_0_translation-- # Create new translation vectors array- new_tvecs = np.zeros_like(tvecs)-- # Apply offset to each camera's translation vector- for cam_i in range(tvecs.shape[0]):- Ri, _ = cv2.Rodrigues(rvecs[cam_i, :])- # Transform the world offset into this camera's coordinate frame- delta_to_origin_camera_i = Ri @ delta_to_origin_world- # Update the translation vector- new_tvecs[cam_i, :] = tvecs[cam_i, :] + delta_to_origin_camera_i- return new_tvecs-- def set_charuco_board_as_groundplane(self, cam_group: freemocap_anipose.CameraGroup):- # Get the camera group object- logger.info("Getting 2d Charuco data")-- charuco_2d_xy: np.ndarray = cam_group.charuco_2d_data-- if charuco_2d_xy is None:- error_message = "Charuco 2d data was not retrieved successfully. Check for an error during calibration."- logger.error(error_message)- raise ValueError(error_message)- logger.info("Charuco 2d data retrieved successfully with shape: "- f"{charuco_2d_xy.shape}")- charuco_2d_xy = charuco_2d_xy.astype(np.float64)- num_cameras, num_frames, num_tracked_points, _ = charuco_2d_xy.shape- charuco_2d_flat = charuco_2d_xy.reshape(num_cameras, -1, 2)-- logger.info("Getting 3d Charuco data")- charuco_3d_flat = self._anipose_camera_group_object.triangulate(- charuco_2d_flat)- charuco_3d_xyz = charuco_3d_flat.reshape(num_frames, num_tracked_points, 3)- logger.info(f"Charuco 3d data reconstructed with shape: {charuco_3d_xyz.shape}")-- charuco_3d_xyz_interpolated = skellyforge_data(raw_charuco_data=charuco_3d_xyz)-- try:- charuco_still_frame_idx = find_good_frame(charuco_data3d_fr_id_xyz=charuco_3d_xyz_interpolated,- number_of_squares_width=self._charuco_board_object.number_of_squares_width,- number_of_squares_height=self._charuco_board_object.number_of_squares_height, )- except CharucoVisibilityError as e:- logger.warning(- "Ground-plane alignment skipped – reverting to original calibration: %s",- e,- exc_info=True, )- success = GroundPlaneSuccess(success=False, error=str(e))- return cam_group, success- except CharucoVelocityError as e:- logger.warning(- "Ground-plane alignment skipped – reverting to original calibration: %s",- e,- exc_info=True, )- success = GroundPlaneSuccess(success=False, error=str(e))- return cam_group, success-- charuco_frame = charuco_3d_xyz_interpolated[charuco_still_frame_idx]-- x_hat, y_hat, z_hat = compute_basis_vectors_of_new_reference(charuco_frame,- number_of_squares_width=self._charuco_board_object.number_of_squares_width,- number_of_squares_height=self._charuco_board_object.number_of_squares_height)- charuco_origin_in_world = charuco_frame[0]- rmat_charuco_to_world = np.column_stack([x_hat, y_hat,- z_hat]) # rotation matrix that transforms a point in the new world reference frame(defined by the charuco) into legacy world frame-- extrinsics = self.adjust_world_reference_frame_to_charuco(cam_group=cam_group,- charuco_origin_in_world=charuco_origin_in_world,- rmat_charuco_to_world=rmat_charuco_to_world)- cam_group.set_rotations(extrinsics.rvecs)- cam_group.set_translations(extrinsics.tvecs)- success = GroundPlaneSuccess(success=True)- logger.info("Anipose camera calibration data adjusted to set charuco board as ground plane")-- charuco_3d_flat = self._anipose_camera_group_object.triangulate(- charuco_2d_flat)- charuco_3d_xyz = charuco_3d_flat.reshape(num_frames, num_tracked_points, 3)- logger.info(f"Charuco 3d data reconstructed with shape: {charuco_3d_xyz.shape}")-- charuco_3d_xyz_interpolated = skellyforge_data(raw_charuco_data=charuco_3d_xyz)-- charuco_save_path = self._recording_folder_path / "output_data" / "charuco_3d_xyz.npy"- np.save(charuco_save_path,- charuco_3d_xyz_interpolated) # NOTE - there may be a more robust way to get this path but this is the simplest for now- logger.info(f"Charuco 3d data saved to {charuco_save_path}")-- return cam_group, success-- def adjust_world_reference_frame_to_charuco(self,- cam_group: freemocap_anipose.CameraGroup,- charuco_origin_in_world: np.ndarray,- rmat_charuco_to_world: np.ndarray):-- tvecs = cam_group.get_translations()- rvecs = cam_group.get_rotations()-- tvecs_new = np.zeros_like(tvecs)- rvecs_new = np.zeros_like(rvecs)-- for i in range(tvecs.shape[0]):- rmat_world_to_cam_i, _ = cv2.Rodrigues(rvecs[i])- # Xcam = Rc->w*Xworld + tvec (base formula for this transformation)- t_delta = rmat_world_to_cam_i @ charuco_origin_in_world # Rc->w*Xworld (rmat is Rc->w)- tvecs_new[i] = t_delta + tvecs[i] # Rc->w*Xworld + tvec-- new_rmat = rmat_world_to_cam_i @ rmat_charuco_to_world # composes w' -> w (rotation matrix) with w -> c (rmat) to get w' -> c- new_rvec, _ = cv2.Rodrigues(new_rmat)- rvecs_new[i] = new_rvec.flatten()- return Extrinsics(rvecs_new, tvecs_new)-- def get_real_world_matrices(self,- cam_group: freemocap_anipose.CameraGroup):- rvecs = cam_group.get_rotations()- tvecs = cam_group.get_translations()-- positions = []- orientations = []- for i in range(tvecs.shape[0]):- rmat_world_to_cam_i, _ = cv2.Rodrigues(rvecs[i])-- rmat_cam_to_world = rmat_world_to_cam_i.T- t_world = -rmat_cam_to_world @ tvecs[i]- positions.append(t_world.astype(float).tolist())- orientations.append(rmat_cam_to_world.astype(float).tolist())-- cam_group.set_world_positions(positions)- cam_group.set_world_orientations(orientations)-- return positions, orientationsdiff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/anipose_camera_calibration/freemocap_anipose.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/anipose_camera_calibration/freemocap_anipose.pydeleted file mode 100644index 6aa8543c..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/anipose_camera_calibration/freemocap_anipose.py+++ /dev/null@@ -1,2201 +0,0 @@-# Most of this was copied (with permission) from the original `aniposelib` package (https://github.com/lambdaloop/aniposelib), and we're adapting it to our needs here. M-# ore info on Anipoise: https://anipose.readthedocs.io/en/latest/--import itertools-import logging-import multiprocessing-import queue-import time-from collections import defaultdict, Counter-from copy import copy-from pathlib import Path-from typing import List--import cv2-import numpy as np-import toml-from aniposelib.boards import extract_points, extract_rtvecs, get_video_params, merge_rows, CharucoBoard-from aniposelib.utils import get_rtvec, make_M-from numba import jit-from scipy import optimize-from scipy import signal-from scipy.cluster.hierarchy import linkage, fcluster-from scipy.cluster.vq import whiten-from scipy.linalg import inv as inverse-from scipy.sparse import dok_matrix-# from skellytracker.process_folder_of_videos import process_list_of_videos-# from skellytracker.trackers.charuco_tracker.charuco_model_info import CharucoModelInfo, CharucoTrackingParams-from tqdm import trange--numba_logger = logging.getLogger("numba")-numba_logger.setLevel(logging.WARNING)--logger = logging.getLogger(__name__)--ARUCO_DICTS = {- (4, 50): cv2.aruco.DICT_4X4_50,- (5, 50): cv2.aruco.DICT_5X5_50,- (6, 50): cv2.aruco.DICT_6X6_50,- (7, 50): cv2.aruco.DICT_7X7_50,- (4, 100): cv2.aruco.DICT_4X4_100,- (5, 100): cv2.aruco.DICT_5X5_100,- (6, 100): cv2.aruco.DICT_6X6_100,- (7, 100): cv2.aruco.DICT_7X7_100,- (4, 250): cv2.aruco.DICT_4X4_250,- (5, 250): cv2.aruco.DICT_5X5_250,- (6, 250): cv2.aruco.DICT_6X6_250,- (7, 250): cv2.aruco.DICT_7X7_250,- (4, 1000): cv2.aruco.DICT_4X4_1000,- (5, 1000): cv2.aruco.DICT_5X5_1000,- (6, 1000): cv2.aruco.DICT_6X6_1000,- (7, 1000): cv2.aruco.DICT_7X7_1000,-}---@jit(nopython=True, parallel=False)-def triangulate_simple(points, camera_mats):- num_cams = len(camera_mats)- A = np.zeros((num_cams * 2, 4))- for i in range(num_cams):- x, y = points[i]- mat = camera_mats[i]- A[(i * 2): (i * 2 + 1)] = x * mat[2] - mat[0]- A[(i * 2 + 1): (i * 2 + 2)] = y * mat[2] - mat[1]- u, s, vh = np.linalg.svd(A, full_matrices=True)- p3d = vh[-1]- p3d = p3d[:3] / p3d[3]- return p3d---def get_error_dict(errors_full, min_points=10):- n_cams = errors_full.shape[0]- errors_norm = np.linalg.norm(errors_full, axis=2)-- good = ~np.isnan(errors_full[:, :, 0])-- error_dict = dict()-- for i in range(n_cams):- for j in range(i + 1, n_cams):- subset = good[i] & good[j]- err_subset = errors_norm[:, subset][[i, j]]- err_subset_mean = np.mean(err_subset, axis=0)- if np.sum(subset) > min_points:- percents = np.percentile(err_subset_mean, [15, 75])- # percents = np.percentile(err_subset, [25, 75])- error_dict[(i, j)] = (err_subset.shape[1], percents)- return error_dict---def check_errors(cgroup, imgp):- p3ds = cgroup.triangulate(imgp)- errors_full = cgroup.reprojection_error(p3ds, imgp, mean=False)- return get_error_dict(errors_full)---def subset_extra(extra, ixs):- if extra is None:- return None-- new_extra = {- "objp": extra["objp"][ixs],- "ids": extra["ids"][ixs],- "rvecs": extra["rvecs"][:, ixs],- "tvecs": extra["tvecs"][:, ixs],- }- return new_extra---def resample_points_extra(imgp, extra, n_samp=25):- n_cams, n_points, _ = imgp.shape- ids = remap_ids(extra["ids"])- n_ids = np.max(ids) + 1- good = ~np.isnan(imgp[:, :, 0])- ixs = np.arange(n_points)-- cam_counts = np.zeros((n_ids, n_cams), dtype="int64")- for idnum in range(n_ids):- cam_counts[idnum] = np.sum(good[:, ids == idnum], axis=1)- cam_counts_random = cam_counts + np.random.random(size=cam_counts.shape)- best_boards = np.argsort(-cam_counts_random, axis=0)-- cam_totals = np.zeros(n_cams, dtype="int64")-- include = set()- for cam_num in range(n_cams):- for board_id in best_boards[:, cam_num]:- include.update(ixs[ids == board_id])- cam_totals += cam_counts[board_id]- if cam_totals[cam_num] >= n_samp or cam_counts_random[board_id, cam_num] < 1:- break-- final_ixs = sorted(include)- newp = imgp[:, final_ixs]- extra = subset_extra(extra, final_ixs)- return newp, extra---def resample_points(imgp, extra=None, n_samp=25):- # if extra is not None:- # return resample_points_extra(imgp, extra, n_samp)-- n_cams = imgp.shape[0]- good = ~np.isnan(imgp[:, :, 0])- ixs = np.arange(imgp.shape[1])-- num_cams = np.sum(~np.isnan(imgp[:, :, 0]), axis=0)-- include = set()-- for i in range(n_cams):- for j in range(i + 1, n_cams):- subset = good[i] & good[j]- n_good = np.sum(subset)- if n_good > 0:- ## pick points, prioritizing points seen by more cameras- arr = np.copy(num_cams[subset]).astype("float64")- arr += np.random.random(size=arr.shape)- picked_ix = np.argsort(-arr)[:n_samp]- picked = ixs[subset][picked_ix]- include.update(picked)-- final_ixs = sorted(include)- newp = imgp[:, final_ixs]- extra = subset_extra(extra, final_ixs)- return newp, extra---def medfilt_data(values, size=15):- padsize = size + 5- vpad = np.pad(values, (padsize, padsize), mode="reflect")- vpadf = signal.medfilt(vpad, kernel_size=size)- return vpadf[padsize:-padsize]---def nan_helper(y):- return np.isnan(y), lambda z: z.nonzero()[0]---def interpolate_data(vals):- nans, ix = nan_helper(vals)- out = np.copy(vals)- try:- out[nans] = np.interp(ix(nans), ix(~nans), vals[~nans])- except ValueError:- out[:] = 0- return out---def remap_ids(ids):- unique_ids = np.unique(ids)- ids_out = np.copy(ids)- for i, num in enumerate(unique_ids):- ids_out[ids == num] = i- return ids_out---def transform_points(points, rvecs, tvecs):- """Rotate points by given rotation vectors and translate.- Rodrigues' rotation formula is used.- """- theta = np.linalg.norm(rvecs, axis=1)[:, np.newaxis]- with np.errstate(invalid="ignore"):- v = rvecs / theta- v = np.nan_to_num(v)- dot = np.sum(points * v, axis=1)[:, np.newaxis]- cos_theta = np.cos(theta)- sin_theta = np.sin(theta)-- rotated = cos_theta * points + sin_theta * np.cross(v, points) + dot * (1 - cos_theta) * v-- return rotated + tvecs---def get_connections(xs, cam_names=None, both=True):- n_cams = xs.shape[0]- n_points = xs.shape[1]-- if cam_names is None:- cam_names = np.arange(n_cams)-- connections = defaultdict(int)-- for rnum in range(n_points):- ixs = np.where(~np.isnan(xs[:, rnum, 0]))[0]- keys = [cam_names[ix] for ix in ixs]- for i in range(len(keys)):- for j in range(i + 1, len(keys)):- a = keys[i]- b = keys[j]- connections[(a, b)] += 1- if both:- connections[(b, a)] += 1-- return connections---def get_calibration_graph(rtvecs, cam_names=None):- n_cams = rtvecs.shape[0]- n_points = rtvecs.shape[1]-- if cam_names is None:- cam_names = np.arange(n_cams)-- connections = get_connections(rtvecs, np.arange(n_cams))-- components = dict(zip(np.arange(n_cams), range(n_cams)))- edges = set(connections.items())-- graph = defaultdict(list)-- for edgenum in range(n_cams - 1):- if len(edges) == 0:- component_names = dict()- for k, v in list(components.items()):- component_names[cam_names[k]] = v- raise ValueError(- """-Could not build calibration graph.-Some group of cameras could not be paired by simultaneous calibration board detections.-Check which cameras have different group numbers below to see the missing edges.-{}""".format(- component_names- )- )-- (a, b), weight = max(edges, key=lambda x: x[1])- graph[a].append(b)- graph[b].append(a)-- match = components[a]- replace = components[b]- for k, v in components.items():- if match == v:- components[k] = replace-- for e in edges.copy():- (a, b), w = e- if components[a] == components[b]:- edges.remove(e)-- return graph---def find_calibration_pairs(graph, source=None):- pairs = []- explored = set()-- if source is None:- source = sorted(graph.keys())[0]-- q = queue.deque()- q.append(source)-- while len(q) > 0:- item = q.pop()- explored.add(item)-- for new in graph[item]:- if new not in explored:- q.append(new)- pairs.append((item, new))- return pairs---def compute_camera_matrices(rtvecs, pairs):- extrinsics = dict()- source = pairs[0][0]- extrinsics[source] = np.identity(4)- for a, b in pairs:- ext = get_transform(rtvecs, b, a)- extrinsics[b] = np.matmul(ext, extrinsics[a])- return extrinsics---def get_transform(rtvecs, left, right):- L = []- for dix in range(rtvecs.shape[1]):- d = rtvecs[:, dix]- good = ~np.isnan(d[:, 0])-- if good[left] and good[right]:- M_left = make_M(d[left, 0:3], d[left, 3:6])- M_right = make_M(d[right, 0:3], d[right, 3:6])- M = np.matmul(M_left, inverse(M_right))- L.append(M)- L_best = select_matrices(L)- M_mean = mean_transform(L_best)- # M_mean = mean_transform_robust(L, M_mean, error=0.5)- # M_mean = mean_transform_robust(L, M_mean, error=0.2)- M_mean = mean_transform_robust(L, M_mean, error=0.1)- return M_mean---def get_most_common(vals):- Z = linkage(whiten(vals), "ward")- n_clust = max(len(vals) / 10, 3)- clusts = fcluster(Z, t=n_clust, criterion="maxclust")- cc = Counter(clusts[clusts >= 0])- most = cc.most_common(n=1)- top = most[0][0]- good = clusts == top- return good---def select_matrices(Ms):- Ms = np.array(Ms)- rvecs = [cv2.Rodrigues(M[:3, :3])[0][:, 0] for M in Ms]- tvecs = np.array([M[:3, 3] for M in Ms])- best = get_most_common(np.hstack([rvecs, tvecs]))- Ms_best = Ms[best]- return Ms_best---def mean_transform(M_list):- rvecs = [cv2.Rodrigues(M[:3, :3])[0][:, 0] for M in M_list]- tvecs = [M[:3, 3] for M in M_list]-- rvec = np.mean(rvecs, axis=0)- tvec = np.mean(tvecs, axis=0)-- return make_M(rvec, tvec)---def mean_transform_robust(M_list, approx=None, error=0.3):- if approx is None:- M_list_robust = M_list- else:- M_list_robust = []- for M in M_list:- rot_error = (M - approx)[:3, :3]- m = np.max(np.abs(rot_error))- if m < error:- M_list_robust.append(M)- return mean_transform(M_list_robust)---def get_initial_extrinsics(rtvecs, cam_names=None):- graph = get_calibration_graph(rtvecs, cam_names)- pairs = find_calibration_pairs(graph, source=0)- extrinsics = compute_camera_matrices(rtvecs, pairs)-- n_cams = rtvecs.shape[0]- rvecs = []- tvecs = []- for cnum in range(n_cams):- rvec, tvec = get_rtvec(extrinsics[cnum])- rvecs.append(rvec)- tvecs.append(tvec)- rvecs = np.array(rvecs)- tvecs = np.array(tvecs)- return rvecs, tvecs---class Camera:- def __init__(- self,- matrix=np.eye(3),- dist=np.zeros(5),- size=None,- rvec=np.zeros(3),- tvec=np.zeros(3),- world_orientation=np.eye(3),- world_position=np.zeros(3),- name=None,- extra_dist=False,- ):- self.set_camera_matrix(matrix)- self.set_distortions(dist)- self.set_size(size)- self.set_rotation(rvec)- self.set_translation(tvec)- self.set_world_orientation(world_orientation)- self.set_world_position(world_position)- self.set_name(name)- self.extra_dist = extra_dist-- def get_dict(self):- return {- "name": self.get_name(),- "size": list(self.get_size()),- "matrix": self.get_camera_matrix().tolist(),- "distortions": self.get_distortions().tolist(),- "rotation": self.get_rotation().tolist(),- "translation": self.get_translation().tolist(),- "world_orientation": self.get_world_orientation().tolist(),- "world_position": self.get_world_position().tolist()- }-- def load_dict(self, d):- self.set_camera_matrix(d["matrix"])- self.set_rotation(d["rotation"])- self.set_translation(d["translation"])- self.set_distortions(d["distortions"])- self.set_name(d["name"])- self.set_size(d["size"])-- self.set_world_orientation(d.get("world_orientation", np.eye(3)))- self.set_world_position(d.get("world_position", np.zeros(3)))-- def from_dict(d):- cam = Camera()- cam.load_dict(d)- return cam-- def get_camera_matrix(self):- return self.matrix-- def get_distortions(self):- return self.dist-- def set_camera_matrix(self, matrix):- self.matrix = np.array(matrix, dtype="float64")-- def set_focal_length(self, fx, fy=None):- if fy is None:- fy = fx- self.matrix[0, 0] = fx- self.matrix[1, 1] = fy-- def get_focal_length(self, both=False):- fx = self.matrix[0, 0]- fy = self.matrix[1, 1]- if both:- return (fx, fy)- else:- return (fx + fy) / 2.0-- def set_distortions(self, dist):- self.dist = np.array(dist, dtype="float64").ravel()-- def set_rotation(self, rvec):- self.rvec = np.array(rvec, dtype="float64").ravel()-- def get_rotation(self):- return self.rvec-- def set_translation(self, tvec):- self.tvec = np.array(tvec, dtype="float64").ravel()-- def get_translation(self):- return self.tvec-- def set_world_orientation(self, world_orientation):- self.world_orientation = np.asarray(world_orientation, dtype="float64").reshape(3, 3)-- def get_world_orientation(self):- return self.world_orientation-- def set_world_position(self, world_position):- self.world_position = np.array(world_position, dtype="float64").ravel()-- def get_world_position(self):- return self.world_position-- def get_extrinsics_mat(self):- return make_M(self.rvec, self.tvec)-- def get_name(self):- return self.name-- def set_name(self, name):- self.name = str(name)-- def set_size(self, size):- """set size as (width, height)"""- self.size = size-- def get_size(self):- """get size as (width, height)"""- return self.size-- def resize_camera(self, scale):- """resize the camera by scale factor, updating intrinsics to match"""- size = self.get_size()- new_size = size[0] * scale, size[1] * scale- matrix = self.get_camera_matrix()- new_matrix = matrix * scale- new_matrix[2, 2] = 1- self.set_size(new_size)- self.set_camera_matrix(new_matrix)-- def get_params(self):- params = np.zeros(8 + self.extra_dist, dtype="float64")- params[0:3] = self.get_rotation()- params[3:6] = self.get_translation()- params[6] = self.get_focal_length()- dist = self.get_distortions()- params[7] = dist[0]- if self.extra_dist:- params[8] = dist[1]- return params-- def set_params(self, params):- self.set_rotation(params[0:3])- self.set_translation(params[3:6])- self.set_focal_length(params[6])-- dist = np.zeros(5, dtype="float64")- dist[0] = params[7]- if self.extra_dist:- dist[1] = params[8]- self.set_distortions(dist)-- def distort_points(self, points):- shape = points.shape- points = points.reshape(-1, 1, 2)- new_points = np.dstack([points, np.ones((points.shape[0], 1, 1))])- out, _ = cv2.projectPoints(- new_points,- np.zeros(3),- np.zeros(3),- self.matrix.astype("float64"),- self.dist.astype("float64"),- )- return out.reshape(shape)-- def undistort_points(self, points):- shape = points.shape- points = points.reshape(-1, 1, 2)- out = cv2.undistortPoints(points, self.matrix.astype("float64"), self.dist.astype("float64"))- return out.reshape(shape)-- def project(self, points):- points = points.reshape(-1, 1, 3)- out, _ = cv2.projectPoints(- points,- self.rvec,- self.tvec,- self.matrix.astype("float64"),- self.dist.astype("float64"),- )- return out-- def single_camera_reprojection_error(self, p3d, p2d):- projecting_3d_points_onto_2d_image_plane_og = self.project(p3d)- projecting_3d_points_onto_2d_image_plane = projecting_3d_points_onto_2d_image_plane_og.reshape(p2d.shape)- return p2d - projecting_3d_points_onto_2d_image_plane-- def copy(self):- return Camera(- matrix=self.get_camera_matrix().copy(),- dist=self.get_distortions().copy(),- size=self.get_size(),- rvec=self.get_rotation().copy(),- tvec=self.get_translation().copy(),- name=self.get_name(),- extra_dist=self.extra_dist,- world_orientation=self.get_world_orientation().copy(),- world_position=self.get_world_position().copy()- )---class FisheyeCamera(Camera):- def __init__(- self,- matrix=np.eye(3),- dist=np.zeros(4),- size=None,- rvec=np.zeros(3),- tvec=np.zeros(3),- name=None,- extra_dist=False,- ):- self.set_camera_matrix(matrix)- self.set_distortions(dist)- self.set_size(size)- self.set_rotation(rvec)- self.set_translation(tvec)- self.set_name(name)- self.extra_dist = extra_dist-- def from_dict(d):- cam = FisheyeCamera()- cam.load_dict(d)- return cam-- def get_dict(self):- d = super().get_dict()- d["fisheye"] = True- return d-- def distort_points(self, points):- shape = points.shape- points = points.reshape(-1, 1, 2)- new_points = np.dstack([points, np.ones((points.shape[0], 1, 1))])- out, _ = cv2.fisheye.projectPoints(- new_points,- np.zeros(3),- np.zeros(3),- self.matrix.astype("float64"),- self.dist.astype("float64"),- )- return out.reshape(shape)-- def undistort_points(self, points):- shape = points.shape- points = points.reshape(-1, 1, 2)- out = cv2.fisheye.undistortPoints(- points.astype("float64"),- self.matrix.astype("float64"),- self.dist.astype("float64"),- )- return out.reshape(shape)-- def project(self, points):- points = points.reshape(-1, 1, 3)- out, _ = cv2.fisheye.projectPoints(- points,- self.rvec,- self.tvec,- self.matrix.astype("float64"),- self.dist.astype("float64"),- )- return out-- def set_params(self, params):- self.set_rotation(params[0:3])- self.set_translation(params[3:6])- self.set_focal_length(params[6])-- dist = np.zeros(4, dtype="float64")- dist[0] = params[7]- if self.extra_dist:- dist[1] = params[8]- # dist[2] = params[9]- # dist[3] = params[10]- self.set_distortions(dist)-- def get_params(self):- params = np.zeros(8 + self.extra_dist, dtype="float64")- params[0:3] = self.get_rotation()- params[3:6] = self.get_translation()- params[6] = self.get_focal_length()- dist = self.get_distortions()- params[7] = dist[0]- if self.extra_dist:- params[8] = dist[1]- # params[9] = dist[2]- # params[10] = dist[3]- return params-- def copy(self):- return FisheyeCamera(- matrix=self.get_camera_matrix().copy(),- dist=self.get_distortions().copy(),- size=self.get_size(),- rvec=self.get_rotation().copy(),- tvec=self.get_translation().copy(),- name=self.get_name(),- extra_dist=self.extra_dist,- )---class CameraGroup:- def __init__(self, cameras, metadata={}):- self.cameras = cameras- self.metadata = metadata- self.charuco_2d_data = None-- def subset_cameras(self, indices):- cams = [self.cameras[ix].copy() for ix in indices]- return CameraGroup(cams, self.metadata)-- def subset_cameras_names(self, names):- cur_names = self.get_names()- cur_names_dict = dict(zip(cur_names, range(len(cur_names))))- indices = []- for name in names:- if name not in cur_names_dict:- raise IndexError("name {} not part of camera names: {}".format(name, cur_names))- indices.append(cur_names_dict[name])- return self.subset_cameras(indices)-- def project(self, points):- """Given an Nx3 array of points, this returns an CxNx2 array of 2D points,- where C is the number of cameras"""- points = points.reshape(-1, 1, 3)- n_points = points.shape[0]- n_cams = len(self.cameras)-- out = np.empty((n_cams, n_points, 2), dtype="float64")- for cnum, cam in enumerate(self.cameras):- out[cnum] = cam.project(points).reshape(n_points, 2)-- return out-- def triangulate(self, points, undistort=True, progress=False, kill_event: multiprocessing.Event = None):- """Given an CxNx2 array, this returns an Nx3 array of points,- where N is the number of points and C is the number of cameras"""-- assert points.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), points.shape- )-- one_point = False- if len(points.shape) == 2:- points = points.reshape(-1, 1, 2)- one_point = True-- if undistort:- new_points = np.empty(points.shape)- for cnum, cam in enumerate(self.cameras):- # must copy in order to satisfy opencv underneath- sub = np.copy(points[cnum])- new_points[cnum] = cam.undistort_points(sub)- points = new_points-- n_cams, n_points, _ = points.shape-- out = np.empty((n_points, 3))- out[:] = np.nan-- cam_mats = np.array([cam.get_extrinsics_mat() for cam in self.cameras])-- if progress:- iterator = trange(n_points, ncols=70)- else:- iterator = range(n_points)-- for ip in iterator:- subp = points[:, ip, :]- good = ~np.isnan(subp[:, 0])- if np.sum(good) >= 2:- out[ip] = triangulate_simple(subp[good], cam_mats[good])-- if kill_event is not None and kill_event.is_set():- return None-- if one_point:- out = out[0]-- return out-- def triangulate_possible(- self,- points,- undistort=True,- min_cams=2,- progress=False,- threshold=0.5,- kill_event: multiprocessing.Event = None,- ):- """Given an CxNxPx2 array, this returns an Nx3 array of points- by triangulating all possible points and picking the ones with- best reprojection error- where:- C: number of cameras- N: number of points- P: number of possible options per point- """-- assert points.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), points.shape- )-- n_cams, n_points, n_possible, _ = points.shape-- cam_nums, point_nums, possible_nums = np.where(~np.isnan(points[:, :, :, 0]))-- all_iters = defaultdict(dict)-- for cam_num, point_num, possible_num in zip(cam_nums, point_nums, possible_nums):- if cam_num not in all_iters[point_num]:- all_iters[point_num][cam_num] = []- all_iters[point_num][cam_num].append((cam_num, possible_num))-- for point_num in all_iters.keys():- for cam_num in all_iters[point_num].keys():- all_iters[point_num][cam_num].append(None)-- out = np.full((n_points, 3), np.nan, dtype="float64")- picked_vals = np.zeros((n_cams, n_points, n_possible), dtype="bool")- errors = np.zeros(n_points, dtype="float64")- points_2d = np.full((n_cams, n_points, 2), np.nan, dtype="float64")-- if progress:- iterator = trange(n_points, ncols=70)- else:- iterator = range(n_points)-- for point_ix in iterator:- best_point = None- best_error = 200-- n_cams_max = len(all_iters[point_ix])-- for picked in itertools.product(*all_iters[point_ix].values()):- picked = [p for p in picked if p is not None]- if len(picked) < min_cams and len(picked) != n_cams_max:- continue-- if kill_event is not None and kill_event.is_set():- return None-- cnums = [p[0] for p in picked]- xnums = [p[1] for p in picked]-- pts = points[cnums, point_ix, xnums]- cc = self.subset_cameras(cnums)-- p3d = cc.triangulate(pts, undistort=undistort)- err = cc.reprojection_error(p3d, pts, mean=True)-- if err < best_error:- best_point = {- "error": err,- "point": p3d[:3],- "points": pts,- "picked": picked,- "joint_ix": point_ix,- }- best_error = err- if best_error < threshold:- break-- if best_point is not None:- out[point_ix] = best_point["point"]- picked = best_point["picked"]- cnums = [p[0] for p in picked]- xnums = [p[1] for p in picked]- picked_vals[cnums, point_ix, xnums] = True- errors[point_ix] = best_point["error"]- points_2d[cnums, point_ix] = best_point["points"]-- # return out, picked_vals, points_2d, errors #original code from OG anipose- return out # simplify output so that `triangulate_ransac` can be used exactly the same way as `triangulate`-- def triangulate_ransac(- self, points, undistort=True, min_cams=2, progress=False, kill_event: multiprocessing.Event = None- ):- """Given an CxNx2 array, this returns an Nx3 array of points,- where N is the number of points and C is the number of cameras"""-- assert points.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), points.shape- )-- n_cams, n_points, _ = points.shape-- points_ransac = points.reshape(n_cams, n_points, 1, 2)-- return self.triangulate_possible(- points_ransac, undistort=undistort, min_cams=min_cams, progress=progress, kill_event=kill_event- )-- @jit(parallel=True, forceobj=True)- def reprojection_error(self, points_3d, points_2d, mean=False):- """Given an Nx3 array of 3D points and an CxNx2 array of 2D points,- where N is the number of points and C is the number of cameras,- this returns an CxNx2 array of errors.- Optionally mean=True, this averages the errors and returns array of length N of errors"""-- one_point = False- if len(points_3d.shape) == 1 and len(points_2d.shape) == 2:- points_3d = points_3d.reshape(1, 3)- points_2d = points_2d.reshape(-1, 1, 2)- one_point = True-- n_cams, n_points, _ = points_2d.shape- assert points_3d.shape == (- n_points,- 3,- ), "shapes of 2D and 3D points are not consistent: " "2D={}, 3D={}".format(points_2d.shape, points_3d.shape)-- errors = np.empty((n_cams, n_points, 2))-- for camera_number, cam in enumerate(self.cameras):- errors[camera_number] = cam.single_camera_reprojection_error(points_3d, points_2d[camera_number])-- if mean:- errors_norm = np.linalg.norm(errors, axis=2)- good = ~np.isnan(errors_norm)- errors_norm[~good] = 0- denom = np.sum(good, axis=0).astype("float64")- denom[denom < 1.5] = np.nan- errors = np.sum(errors_norm, axis=0) / denom-- if one_point:- if mean:- errors = float(errors[0])- else:- errors = errors.reshape(-1, 2)-- return errors-- def bundle_adjust_iter(- self,- p2ds,- extra=None,- n_iters=10,- start_mu=15,- end_mu=1,- max_nfev=200,- ftol=1e-4,- n_samp_iter=100,- n_samp_full=1000,- error_threshold=0.3,- verbose=False,- ):- """Given an CxNx2 array of 2D points,- where N is the number of points and C is the number of cameras,- this performs iterative bundle adjustsment to fine-tune the parameters of the cameras.- That is, it performs bundle adjustment multiple times, adjusting the weights given to points- to reduce the influence of outliers.- This is inspired by the algorithm for Fast Global Registration by Zhou, Park, and Koltun- """- error_list = []-- assert p2ds.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), p2ds.shape- )-- p2ds_full = p2ds- extra_full = extra-- p2ds, extra = resample_points(p2ds_full, extra_full, n_samp=n_samp_full)- error = self.average_error(p2ds, median=True)-- if verbose:- print("error: ", error)-- mus = np.exp(np.linspace(np.log(start_mu), np.log(end_mu), num=n_iters))-- if verbose:- print("n_samples: {}".format(n_samp_iter))-- for i in range(n_iters):- p2ds, extra = resample_points(p2ds_full, extra_full, n_samp=n_samp_full)- p3ds = self.triangulate(p2ds)- errors_full = self.reprojection_error(p3ds, p2ds, mean=False)- errors_norm = self.reprojection_error(p3ds, p2ds, mean=True)-- error_dict = get_error_dict(errors_full)- max_error = 0- min_error = 0- for k, v in error_dict.items():- num, percents = v- max_error = max(percents[-1], max_error)- min_error = max(percents[0], min_error)- mu = max(min(max_error, mus[i]), min_error)-- good = errors_norm < mu- extra_good = subset_extra(extra, good)- p2ds_samp, extra_samp = resample_points(p2ds[:, good], extra_good, n_samp=n_samp_iter)-- error = np.median(errors_norm)- error_list.append(error)-- if error < error_threshold:- break-- if verbose:- print(error_dict)- print("error: {:.2f}, mu: {:.1f}, ratio: {:.3f}".format(error, mu, np.mean(good)))- print(f"previous error scores: [magenta] {error_list}[/magenta]")-- self.bundle_adjust(- p2ds_samp,- extra_samp,- loss="linear",- ftol=ftol,- max_nfev=max_nfev,- verbose=verbose,- )-- p2ds, extra = resample_points(p2ds_full, extra_full, n_samp=n_samp_full)- p3ds = self.triangulate(p2ds)- errors_full = self.reprojection_error(p3ds, p2ds, mean=False)- errors_norm = self.reprojection_error(p3ds, p2ds, mean=True)- error_dict = get_error_dict(errors_full)- if verbose:- print(error_dict)-- max_error = 0- min_error = 0- for k, v in error_dict.items():- num, percents = v- max_error = max(percents[-1], max_error)- min_error = max(percents[0], min_error)- mu = max(max(max_error, end_mu), min_error)-- good = errors_norm < mu- extra_good = subset_extra(extra, good)- self.bundle_adjust(- p2ds[:, good],- extra_good,- loss="linear",- ftol=ftol,- max_nfev=max(200, max_nfev),- verbose=verbose,- )-- error = self.average_error(p2ds, median=True)-- p3ds = self.triangulate(p2ds)- errors_full = self.reprojection_error(p3ds, p2ds, mean=False)- error_dict = get_error_dict(errors_full)- if verbose:- print(error_dict)-- if verbose:- print("error: ", error)-- return error-- def bundle_adjust(- self,- p2ds,- extra=None,- loss="linear",- threshold=50,- ftol=1e-4,- max_nfev=1000,- weights=None,- start_params=None,- verbose=True,- ):- """Given an CxNx2 array of 2D points,- where N is the number of points and C is the number of cameras,- this performs bundle adjustsment to fine-tune the parameters of the cameras"""-- assert p2ds.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), p2ds.shape- )-- if extra is not None:- extra["ids_map"] = remap_ids(extra["ids"])-- x0, n_cam_params = self._initialize_params_bundle(p2ds, extra)-- if start_params is not None:- x0 = start_params- n_cam_params = len(self.cameras[0].get_params())-- error_fun = self._error_fun_bundle-- jac_sparse = self._jac_sparsity_bundle(p2ds, n_cam_params, extra)-- f_scale = threshold- opt = optimize.least_squares(- error_fun,- x0,- jac_sparsity=jac_sparse,- f_scale=f_scale,- x_scale="jac",- loss=loss,- ftol=ftol,- method="trf",- tr_solver="lsmr",- verbose=2 * verbose,- max_nfev=max_nfev,- args=(p2ds, n_cam_params, extra),- )- best_params = opt.x-- for i, cam in enumerate(self.cameras):- a = i * n_cam_params- b = (i + 1) * n_cam_params- cam.set_params(best_params[a:b])-- error = self.average_error(p2ds)- return error-- @jit(parallel=True, forceobj=True)- def _error_fun_bundle(self, params, p2ds, n_cam_params, extra):- """Error function for bundle adjustment"""- good = ~np.isnan(p2ds)- n_cams = len(self.cameras)-- for i in range(n_cams):- cam = self.cameras[i]- a = i * n_cam_params- b = (i + 1) * n_cam_params- cam.set_params(params[a:b])-- n_cams = len(self.cameras)- sub = n_cam_params * n_cams- n3d = p2ds.shape[1] * 3- p3ds_test = params[sub: sub + n3d].reshape(-1, 3)- errors = self.reprojection_error(p3ds_test, p2ds)- errors_reproj = errors[good]-- if extra is not None:- ids = extra["ids_map"]- objp = extra["objp"]- min_scale = np.min(objp[objp > 0])- n_boards = int(np.max(ids)) + 1- a = sub + n3d- rvecs = params[a: a + n_boards * 3].reshape(-1, 3)- tvecs = params[a + n_boards * 3: a + n_boards * 6].reshape(-1, 3)- expected = transform_points(objp, rvecs[ids], tvecs[ids])- errors_obj = 2 * (p3ds_test - expected).ravel() / min_scale- else:- errors_obj = np.array([])-- return np.hstack([errors_reproj, errors_obj])-- def _jac_sparsity_bundle(self, p2ds, n_cam_params, extra):- """Given an CxNx2 array of 2D points,- where N is the number of points and C is the number of cameras,- compute the sparsity structure of the jacobian for bundle adjustment"""-- point_indices = np.zeros(p2ds.shape, dtype="int32")- cam_indices = np.zeros(p2ds.shape, dtype="int32")-- for i in range(p2ds.shape[1]):- point_indices[:, i] = i-- for j in range(p2ds.shape[0]):- cam_indices[j] = j-- good = ~np.isnan(p2ds)-- if extra is not None:- ids = extra["ids_map"]- n_boards = int(np.max(ids)) + 1- total_board_params = n_boards * (3 + 3) # rvecs + tvecs- else:- n_boards = 0- total_board_params = 0-- n_cams = p2ds.shape[0]- n_points = p2ds.shape[1]- total_params_reproj = n_cams * n_cam_params + n_points * 3- n_params = total_params_reproj + total_board_params-- n_good_values = np.sum(good)- if extra is not None:- n_errors = n_good_values + n_points * 3- else:- n_errors = n_good_values-- A_sparse = dok_matrix((n_errors, n_params), dtype="int16")-- cam_indices_good = cam_indices[good]- point_indices_good = point_indices[good]-- # -- reprojection error --- ix = np.arange(n_good_values)-- ## update camera params based on point error- for i in range(n_cam_params):- A_sparse[ix, cam_indices_good * n_cam_params + i] = 1-- ## update point position based on point error- for i in range(3):- A_sparse[ix, n_cams * n_cam_params + point_indices_good * 3 + i] = 1-- # -- match for the object points--- if extra is not None:- point_ix = np.arange(n_points)-- ## update all the camera parameters- # A_sparse[n_good_values:n_good_values+n_points*3,- # 0:n_cams*n_cam_params] = 1-- ## update board rotation and translation based on error from expected- for i in range(3):- for j in range(3):- A_sparse[- n_good_values + point_ix * 3 + i,- total_params_reproj + ids * 3 + j,- ] = 1- A_sparse[- n_good_values + point_ix * 3 + i,- total_params_reproj + n_boards * 3 + ids * 3 + j,- ] = 1-- ## update point position based on error from expected- for i in range(3):- A_sparse[- n_good_values + point_ix * 3 + i,- n_cams * n_cam_params + point_ix * 3 + i,- ] = 1-- return A_sparse-- def _initialize_params_bundle(self, p2ds, extra):- """Given an CxNx2 array of 2D points,- where N is the number of points and C is the number of cameras,- initializes the parameters for bundle adjustment"""-- cam_params = np.hstack([cam.get_params() for cam in self.cameras])- n_cam_params = len(cam_params) // len(self.cameras)-- total_cam_params = len(cam_params)-- n_cams, n_points, _ = p2ds.shape- assert n_cams == len(self.cameras), (- "number of cameras in CameraGroup does not " "match number of cameras in 2D points given"- )-- p3ds = self.triangulate(p2ds)-- if extra is not None:- ids = extra["ids_map"]- n_boards = int(np.max(ids[~np.isnan(ids)])) + 1- total_board_params = n_boards * (3 + 3) # rvecs + tvecs-- # initialize to 0- rvecs = np.zeros((n_boards, 3), dtype="float64")- tvecs = np.zeros((n_boards, 3), dtype="float64")-- if "rvecs" in extra and "tvecs" in extra:- rvecs_all = extra["rvecs"]- tvecs_all = extra["tvecs"]- for board_num in range(n_boards):- point_id = np.where(ids == board_num)[0][0]- cam_ids_possible = np.where(~np.isnan(p2ds[:, point_id, 0]))[0]- cam_id = np.random.choice(cam_ids_possible)- M_cam = self.cameras[cam_id].get_extrinsics_mat()- M_board_cam = make_M(rvecs_all[cam_id, point_id], tvecs_all[cam_id, point_id])- M_board = np.matmul(inverse(M_cam), M_board_cam)- rvec, tvec = get_rtvec(M_board)- rvecs[board_num] = rvec- tvecs[board_num] = tvec-- else:- total_board_params = 0-- x0 = np.zeros(total_cam_params + p3ds.size + total_board_params)- x0[:total_cam_params] = cam_params- x0[total_cam_params: total_cam_params + p3ds.size] = p3ds.ravel()-- if extra is not None:- start_board = total_cam_params + p3ds.size- x0[start_board: start_board + n_boards * 3] = rvecs.ravel()- x0[start_board + n_boards * 3: start_board + n_boards * 6] = tvecs.ravel()-- return x0, n_cam_params-- def optim_points(- self,- points,- p3ds,- constraints=[],- constraints_weak=[],- scale_smooth=4,- scale_length=2,- scale_length_weak=0.5,- reproj_error_threshold=15,- reproj_loss="soft_l1",- n_deriv_smooth=1,- scores=None,- verbose=False,- ):- """- Take in an array of 2D points of shape CxNxJx2,- an array of 3D points of shape NxJx3,- and an array of constraints of shape Kx2, where- C: number of camera- N: number of frames- J: number of joints- K: number of constraints-- This function creates an optimized array of 3D points of shape NxJx3.-- Example constraints:- constraints = [[0, 1], [1, 2], [2, 3]]- (meaning that lengths of segments 0->1, 1->2, 2->3 are all constant)-- """- assert points.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), points.shape- )-- n_cams, n_frames, n_joints, _ = points.shape- constraints = np.array(constraints)- constraints_weak = np.array(constraints_weak)-- p3ds_intp = np.apply_along_axis(interpolate_data, 0, p3ds)-- p3ds_med = np.apply_along_axis(medfilt_data, 0, p3ds_intp, size=7)-- default_smooth = 1.0 / np.mean(np.abs(np.diff(p3ds_med, axis=0)))- scale_smooth_full = scale_smooth * default_smooth-- t1 = time.time()-- x0 = self._initialize_params_triangulation(p3ds_intp, constraints, constraints_weak)-- x0[~np.isfinite(x0)] = 0-- jac = self._jac_sparsity_triangulation(points, constraints, constraints_weak, n_deriv_smooth)-- opt2 = optimize.least_squares(- self._error_fun_triangulation,- x0=x0,- jac_sparsity=jac,- loss="linear",- ftol=1e-3,- verbose=2 * verbose,- args=(- points,- constraints,- constraints_weak,- scores,- scale_smooth_full,- scale_length,- scale_length_weak,- reproj_error_threshold,- reproj_loss,- n_deriv_smooth,- ),- )-- p3ds_new2 = opt2.x[: p3ds.size].reshape(p3ds.shape)-- t2 = time.time()-- if verbose:- print("optimization took {:.2f} seconds".format(t2 - t1))-- return p3ds_new2-- def optim_points_possible(- self,- points,- p3ds,- constraints=[],- constraints_weak=[],- scale_smooth=4,- scale_length=2,- scale_length_weak=0.5,- reproj_error_threshold=15,- reproj_loss="soft_l1",- n_deriv_smooth=1,- scores=None,- verbose=False,- ):- """- Take in an array of 2D points of shape CxNxJxPx2,- an array of 3D points of shape NxJx3,- and an array of constraints of shape Kx2, where- C: number of camera- N: number of frames- J: number of joints- P: number of possible options per point- K: number of constraints-- This function creates an optimized array of 3D points of shape NxJx3.-- Example constraints:- constraints = [[0, 1], [1, 2], [2, 3]]- (meaning that lengths of segments 0->1, 1->2, 2->3 are all constant)-- """- assert points.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), points.shape- )-- n_cams, n_frames, n_joints, n_possible, _ = points.shape- constraints = np.array(constraints)- constraints_weak = np.array(constraints_weak)-- p3ds_intp = np.apply_along_axis(interpolate_data, 0, p3ds)-- p3ds_med = np.apply_along_axis(medfilt_data, 0, p3ds_intp, size=7)-- default_smooth = 1.0 / np.mean(np.abs(np.diff(p3ds_med, axis=0)))- scale_smooth_full = scale_smooth * default_smooth-- t1 = time.time()-- x0 = self._initialize_params_triangulation_possible(- p3ds_intp,- points,- constraints=constraints,- constraints_weak=constraints_weak,- )-- print("getting jacobian...")- jac = self._jac_sparsity_triangulation_possible(- points,- constraints=constraints,- constraints_weak=constraints_weak,- n_deriv_smooth=n_deriv_smooth,- )-- beta = 5-- print("starting optimization...")- opt2 = optimize.least_squares(- self._error_fun_triangulation_possible,- x0=x0,- jac_sparsity=jac,- loss="linear",- ftol=1e-3,- verbose=2 * verbose,- args=(- points,- beta,- constraints,- constraints_weak,- scores,- scale_smooth_full,- scale_length,- scale_length_weak,- reproj_error_threshold,- reproj_loss,- n_deriv_smooth,- ),- )- params = opt2.x-- p3ds_new2 = params[: p3ds.size].reshape(p3ds.shape)-- bad = np.isnan(points[:, :, :, :, 0])- all_bad = np.all(bad, axis=3)-- n_params_norm = p3ds.size + len(constraints) + len(constraints_weak)-- alphas = np.zeros((n_cams, n_frames, n_joints, n_possible), dtype="float64")- alphas[~bad] = params[n_params_norm:]-- alphas_exp = np.exp(beta * alphas)- alphas_exp[bad] = 0- alphas_sum = np.sum(alphas_exp, axis=3)- alphas_sum[all_bad] = 1- alphas_norm = alphas_exp / alphas_sum[:, :, :, None]- alphas_norm[bad] = np.nan-- t2 = time.time()-- if verbose:- print("optimization took {:.2f} seconds".format(t2 - t1))-- return p3ds_new2, alphas_norm-- def triangulate_optim(self, points, init_ransac=False, init_progress=False, **kwargs):- """- Take in an array of 2D points of shape CxNxJx2, and an array of constraints of shape Kx2, where- C: number of camera- N: number of frames- J: number of joints- K: number of constraints-- This function creates an optimized array of 3D points of shape NxJx3.-- Example constraints:- constraints = [[0, 1], [1, 2], [2, 3]]- (meaning that lengths of segments 0->1, 1->2, 2->3 are all constant)-- """-- assert points.shape[0] == len(- self.cameras- ), "Invalid points shape, first dim should be equal to" " number of cameras ({}), but shape is {}".format(- len(self.cameras), points.shape- )-- n_cams, n_frames, n_joints, _ = points.shape- # constraints = np.array(constraints)- # constraints_weak = np.array(constraints_weak)-- points_shaped = points.reshape(n_cams, n_frames * n_joints, 2)- if init_ransac:- p3ds, picked, p2ds, errors = self.triangulate_ransac(points_shaped, progress=init_progress)- points = p2ds.reshape(points.shape)- else:- p3ds = self.triangulate(points_shaped, progress=init_progress)- p3ds = p3ds.reshape((n_frames, n_joints, 3))-- c = np.isfinite(p3ds[:, :, 0])- if np.sum(c) < 20:- print("warning: not enough 3D points to calculate_center_of_mass optimization")- return p3ds-- return self.optim_points(points, p3ds, **kwargs)-- @jit(forceobj=True, parallel=True)- def _error_fun_triangulation(- self,- params,- p2ds,- constraints=[],- constraints_weak=[],- scores=None,- scale_smooth=10000,- scale_length=1,- scale_length_weak=0.2,- reproj_error_threshold=100,- reproj_loss="soft_l1",- n_deriv_smooth=1,- ):- n_cams, n_frames, n_joints, _ = p2ds.shape-- n_3d = n_frames * n_joints * 3- n_constraints = len(constraints)- n_constraints_weak = len(constraints_weak)-- # load params- p3ds = params[:n_3d].reshape((n_frames, n_joints, 3))- joint_lengths = np.array(params[n_3d: n_3d + n_constraints])- joint_lengths_weak = np.array(params[n_3d + n_constraints:])-- # reprojection errors- p3ds_flat = p3ds.reshape(-1, 3)- p2ds_flat = p2ds.reshape((n_cams, -1, 2))- errors = self.reprojection_error(p3ds_flat, p2ds_flat)- if scores is not None:- scores_flat = scores.reshape((n_cams, -1))- errors = errors * scores_flat[:, :, None]- errors_reproj = errors[~np.isnan(p2ds_flat)]-- rp = reproj_error_threshold- errors_reproj = np.abs(errors_reproj)- if reproj_loss == "huber":- bad = errors_reproj > rp- errors_reproj[bad] = rp * (2 * np.sqrt(errors_reproj[bad] / rp) - 1)- elif reproj_loss == "linear":- pass- elif reproj_loss == "soft_l1":- errors_reproj = rp * 2 * (np.sqrt(1 + errors_reproj / rp) - 1)-- # temporal constraint- errors_smooth = np.diff(p3ds, n=n_deriv_smooth, axis=0).ravel() * scale_smooth-- # joint length constraint- errors_lengths = np.empty((n_constraints, n_frames), dtype="float64")- for cix, (a, b) in enumerate(constraints):- lengths = np.linalg.norm(p3ds[:, a] - p3ds[:, b], axis=1)- expected = joint_lengths[cix]- errors_lengths[cix] = 100 * (lengths - expected) / expected- errors_lengths = errors_lengths.ravel() * scale_length-- errors_lengths_weak = np.empty((n_constraints_weak, n_frames), dtype="float64")- for cix, (a, b) in enumerate(constraints_weak):- lengths = np.linalg.norm(p3ds[:, a] - p3ds[:, b], axis=1)- expected = joint_lengths_weak[cix]- errors_lengths_weak[cix] = 100 * (lengths - expected) / expected- errors_lengths_weak = errors_lengths_weak.ravel() * scale_length_weak-- return np.hstack([errors_reproj, errors_smooth, errors_lengths, errors_lengths_weak])-- def _error_fun_triangulation_possible(self, params, p2ds, beta=2, constraints=[], constraints_weak=[], *args):- # extract alphas from end of params- # soft argmax for picking the appropriate points from p2ds- # pass the points to error_fun_triangulate_possible for residuals- # add errors to keep the alphas in check- # return all the errors-- n_cams, n_frames, n_joints, n_possible, _ = p2ds.shape-- n_3d = n_frames * n_joints * 3- n_constraints = len(constraints)- n_constraints_weak = len(constraints_weak)- n_params_norm = n_3d + n_constraints + n_constraints_weak-- # load params- bad = np.isnan(p2ds[:, :, :, :, 0])- all_bad = np.all(bad, axis=3)-- alphas = np.zeros((n_cams, n_frames, n_joints, n_possible), dtype="float64")- alphas[~bad] = params[n_params_norm:]- params_rest = np.array(params[:n_params_norm])-- # get normalized alphas- alphas_exp = np.exp(beta * alphas)- alphas_exp[bad] = 0- alphas_sum = np.sum(alphas_exp, axis=3)- alphas_sum[all_bad] = 1- alphas_norm = alphas_exp / alphas_sum[:, :, :, None]-- # extract the 2D points using soft argmax- p2ds_test = np.copy(p2ds)- p2ds_test[bad] = 0- p2ds_adj = np.sum(alphas_norm[:, :, :, :, None] * p2ds_test, axis=3)- p2ds_adj[all_bad] = np.nan-- errors = self._error_fun_triangulation(params_rest, p2ds_adj, constraints, constraints_weak, *args)-- alphas_test = alphas_norm[~all_bad]- errors_alphas = (1 - np.std(alphas_test, axis=1)) * 10-- return np.hstack([errors, errors_alphas])-- def _initialize_params_triangulation(self, p3ds, constraints=[], constraints_weak=[]):- joint_lengths = np.empty(len(constraints), dtype="float64")- joint_lengths_weak = np.empty(len(constraints_weak), dtype="float64")-- for cix, (a, b) in enumerate(constraints):- lengths = np.linalg.norm(p3ds[:, a] - p3ds[:, b], axis=1)- joint_lengths[cix] = np.median(lengths)-- for cix, (a, b) in enumerate(constraints_weak):- lengths = np.linalg.norm(p3ds[:, a] - p3ds[:, b], axis=1)- joint_lengths_weak[cix] = np.median(lengths)-- all_lengths = np.hstack([joint_lengths, joint_lengths_weak])- med = np.median(all_lengths)- if med == 0:- med = 1e-3-- mad = np.median(np.abs(all_lengths - med))-- joint_lengths[joint_lengths == 0] = med- joint_lengths_weak[joint_lengths_weak == 0] = med- joint_lengths[joint_lengths > med + mad * 5] = med- joint_lengths_weak[joint_lengths_weak > med + mad * 5] = med-- return np.hstack([p3ds.ravel(), joint_lengths, joint_lengths_weak])-- def _initialize_params_triangulation_possible(self, p3ds, p2ds, **kwargs):- # initialize params using above function- # initialize alphas to 1 for first one and 0 for other possible-- n_cams, n_frames, n_joints, n_possible, _ = p2ds.shape- good = ~np.isnan(p2ds[:, :, :, :, 0])-- alphas = np.zeros((n_cams, n_frames, n_joints, n_possible), dtype="float64")- alphas[:, :, :, 0] = 0-- params = self._initialize_params_triangulation(p3ds, **kwargs)- params_full = np.hstack([params, alphas[good]])-- return params_full-- def _jac_sparsity_triangulation(self, p2ds, constraints=[], constraints_weak=[], n_deriv_smooth=1):- n_cams, n_frames, n_joints, _ = p2ds.shape- n_constraints = len(constraints)- n_constraints_weak = len(constraints_weak)-- p2ds_flat = p2ds.reshape((n_cams, -1, 2))-- point_indices = np.zeros(p2ds_flat.shape, dtype="int32")- for i in range(p2ds_flat.shape[1]):- point_indices[:, i] = i-- point_indices_3d = np.arange(n_frames * n_joints).reshape((n_frames, n_joints))-- good = ~np.isnan(p2ds_flat)- n_errors_reproj = np.sum(good)- n_errors_smooth = (n_frames - n_deriv_smooth) * n_joints * 3- n_errors_lengths = n_constraints * n_frames- n_errors_lengths_weak = n_constraints_weak * n_frames-- n_errors = n_errors_reproj + n_errors_smooth + n_errors_lengths + n_errors_lengths_weak-- n_3d = n_frames * n_joints * 3- n_params = n_3d + n_constraints + n_constraints_weak-- point_indices_good = point_indices[good]-- A_sparse = dok_matrix((n_errors, n_params), dtype="int16")-- # constraints for reprojection errors- ix_reproj = np.arange(n_errors_reproj)- for k in range(3):- A_sparse[ix_reproj, point_indices_good * 3 + k] = 1-- # sparse constraints for smoothness in time- frames = np.arange(n_frames - n_deriv_smooth)- for j in range(n_joints):- for n in range(n_deriv_smooth + 1):- pa = point_indices_3d[frames, j]- pb = point_indices_3d[frames + n, j]- for k in range(3):- A_sparse[n_errors_reproj + pa * 3 + k, pb * 3 + k] = 1-- ## -- strong constraints --- # joint lengths should change with joint lengths errors- start = n_errors_reproj + n_errors_smooth- frames = np.arange(n_frames)- for cix, (a, b) in enumerate(constraints):- A_sparse[start + cix * n_frames + frames, n_3d + cix] = 1-- # points should change accordingly to match joint lengths too- frames = np.arange(n_frames)- for cix, (a, b) in enumerate(constraints):- pa = point_indices_3d[frames, a]- pb = point_indices_3d[frames, b]- for k in range(3):- A_sparse[start + cix * n_frames + frames, pa * 3 + k] = 1- A_sparse[start + cix * n_frames + frames, pb * 3 + k] = 1-- ## -- weak constraints --- # joint lengths should change with joint lengths errors- start = n_errors_reproj + n_errors_smooth + n_errors_lengths- frames = np.arange(n_frames)- for cix, (a, b) in enumerate(constraints_weak):- A_sparse[start + cix * n_frames + frames, n_3d + n_constraints + cix] = 1-- # points should change accordingly to match joint lengths too- frames = np.arange(n_frames)- for cix, (a, b) in enumerate(constraints_weak):- pa = point_indices_3d[frames, a]- pb = point_indices_3d[frames, b]- for k in range(3):- A_sparse[start + cix * n_frames + frames, pa * 3 + k] = 1- A_sparse[start + cix * n_frames + frames, pb * 3 + k] = 1-- return A_sparse-- def _jac_sparsity_triangulation_possible(self, p2ds_full, **kwargs):- # initialize sparse jacobian using above function- # extend to include alphas from parameters- ## TODO: this initialization is really slow for some reason-- n_cams, n_frames, n_joints, n_possible, _ = p2ds_full.shape- good_full = ~np.isnan(p2ds_full[:, :, :, :, 0])- any_good = np.any(good_full, axis=3)-- n_alphas = np.sum(good_full)- n_errors_alphas = np.sum(any_good)-- p2ds = p2ds_full[:, :, :, 0]- A_sparse = self._jac_sparsity_triangulation(p2ds, **kwargs)-- n_errors, n_params = A_sparse.shape-- B_sparse = dok_matrix((n_errors + n_errors_alphas, n_params + n_alphas), dtype="int16")- for r, c in zip(*A_sparse.nonzero()):- B_sparse[r, c] = A_sparse[r, c]-- point_indices_2d = np.arange(n_cams * n_frames * n_joints).reshape(n_cams, n_frames, n_joints)- point_indices_2d_rep = np.repeat(point_indices_2d[:, :, :, None], 2, axis=3)- point_indices_2d_good = point_indices_2d_rep[~np.isnan(p2ds)]- point_indices_good = point_indices_2d[any_good]-- alpha_indices = np.zeros((n_cams, n_frames, n_joints, n_possible), dtype="int64")- for pnum in range(n_possible):- alpha_indices[:, :, :, pnum] = point_indices_2d-- alpha_indices_good = alpha_indices[good_full]-- # alphas should change according to the reprojection error for each corresponding point- point_indices_2d_good_find = defaultdict(list)- for ix, p in enumerate(point_indices_2d_good):- point_indices_2d_good_find[p].append(ix)-- for ix, alpha_index in enumerate(alpha_indices_good):- B_sparse[point_indices_2d_good_find[alpha_index], n_params + ix] = 1-- # alphas should change according to the alpha errors- point_indices_good_find = dict()- for ix, p in enumerate(point_indices_good):- point_indices_good_find[p] = ix-- for ix, alpha_index in enumerate(alpha_indices_good):- if alpha_index in point_indices_good_find:- err_ix = n_errors + point_indices_good_find[alpha_index]- B_sparse[err_ix, n_params + ix] = 1-- return B_sparse-- def copy(self):- cameras = [cam.copy() for cam in self.cameras]- metadata = copy(self.metadata)- return CameraGroup(cameras, metadata)-- def set_rotations(self, rvecs):- for cam, rvec in zip(self.cameras, rvecs):- cam.set_rotation(rvec)-- def set_translations(self, tvecs):- for cam, tvec in zip(self.cameras, tvecs):- cam.set_translation(tvec)-- def set_world_positions(self, positions):- for cam, position, in zip(self.cameras, positions):- cam.set_world_position(position)-- def set_world_orientations(self, orientations):- for cam, orientation in zip(self.cameras, orientations):- cam.set_world_orientation(orientation)-- def get_world_positions(self):- return np.stack([cam.get_world_position() for cam in self.cameras])-- def get_world_orientations(self):- return np.stack([cam.get_world_orientation() for cam in self.cameras])-- def get_rotations(self):- rvecs = []- for cam in self.cameras:- rvec = cam.get_rotation()- rvecs.append(rvec)- return np.array(rvecs)-- def get_translations(self):- tvecs = []- for cam in self.cameras:- tvec = cam.get_translation()- tvecs.append(tvec)- return np.array(tvecs)-- def get_names(self):- return [cam.get_name() for cam in self.cameras]-- def set_names(self, names):- for cam, name in zip(self.cameras, names):- cam.set_name(name)-- def average_error(self, p2ds, median=False):- p3ds = self.triangulate(p2ds)- errors = self.reprojection_error(p3ds, p2ds, mean=True)- if median:- return np.median(errors)- else:- return np.mean(errors)-- def calibrate_rows(- self,- all_rows,- board,- init_intrinsics=True,- init_extrinsics=True,- verbose=True,- **kwargs,- ):- assert len(all_rows) == len(self.cameras), "Number of camera detections does not match number of cameras"-- for rows, camera in zip(all_rows, self.cameras):- size = camera.get_size()-- assert size is not None, "Camera with name {} has no specified frame size".format(camera.get_name())-- if init_intrinsics:- objp, imgp = board.get_all_calibration_points(rows)- mixed = [(o, i) for (o, i) in zip(objp, imgp) if len(o) >= 7]- assert len(objp) != 0 and len(imgp) != 0, "No Charuco board points detected"- objp, imgp = zip(*mixed)- matrix = cv2.initCameraMatrix2D(objp, imgp, tuple(size))- camera.set_camera_matrix(matrix)-- for i, (row, cam) in enumerate(zip(all_rows, self.cameras)):- all_rows[i] = board.estimate_pose_rows(cam, row)-- charuco_frames = [f["framenum"][1] for f in all_rows[0]]- merged = merge_rows(all_rows)- imgp, extra = extract_points(merged, board, min_cameras=2)-- if init_extrinsics:- rtvecs = extract_rtvecs(merged)- if verbose:- print(get_connections(rtvecs, self.get_names()))- rvecs, tvecs = get_initial_extrinsics(rtvecs)- self.set_rotations(rvecs)- self.set_translations(tvecs)-- error = self.bundle_adjust_iter(imgp, extra, verbose=verbose, error_threshold=1)-- return error, merged, charuco_frames-- def get_rows_videos(self, videos: List[List[str]], board: "AniposeCharucoBoard", verbose: bool = True):- num_corners = board.total_size- self._get_charuco_2d_data(videos=videos, board=board)-- if self.charuco_2d_data is None:- raise ValueError(- "Charuco 2D data has not been initialized. Call _get_charuco_2d_data() first, or check for errors in the video processing.")-- all_rows = []-- num_cameras, num_frames, _, _ = self.charuco_2d_data.shape- for camera_number in range(num_cameras):- camera_rows = []- for frame in range(num_frames):- filled = self.charuco_2d_data[camera_number, frame, :, :]- filled = filled.astype(np.float32)- filled = np.reshape(filled, (num_corners, 1, 2)) # Add empty column anipose expects- mask = (~np.isnan(filled[:, :, 0])) & (~np.isnan(filled[:, :, 1]))- non_empty_ids = np.where(mask)[0]- corners = filled[non_empty_ids, :, :]- non_empty_ids = non_empty_ids.reshape(-1, 1) # Add empty column anipose expects- if corners.shape[0] != 0:- row = {- "framenum": (0, frame),- "corners": corners,- "ids": non_empty_ids,- "filled": filled,- }- camera_rows.append(row)- all_rows.append(camera_rows)- if verbose:- print(f"Charuco detection results:")- for i, rows in enumerate(all_rows):- print(f"\tCamera {i} has {len(rows)} frames with detected corners.")-- return all_rows-- def _get_charuco_2d_data(self, videos: List[List[str]], board: "AniposeCharucoBoard"):- """- Processes a list of a list of videos to extract Charuco 2D data.-- Should be called once during the initial calibration, and then referenced with self.charuco_2d_data- """- video_paths = [Path(video[0]) for video in videos]- charuco_2d_data = process_list_of_videos(- model_info=CharucoModelInfo(),- tracking_params=CharucoTrackingParams(- charuco_squares_x_in=board.squaresX,- charuco_squares_y_in=board.squaresY,- charuco_dict_id=ARUCO_DICTS[(board.marker_bits, board.dict_size)]- ),- video_paths=video_paths,- num_processes=min(len(videos), multiprocessing.cpu_count() - 1),- )-- self.charuco_2d_data = charuco_2d_data-- def set_camera_sizes_videos(self, videos):- for cix, (cam, cam_videos) in enumerate(zip(self.cameras, videos)):- rows_cam = []- for vnum, vidname in enumerate(cam_videos):- params = get_video_params(vidname)- size = (params["width"], params["height"])- cam.set_size(size)-- def calibrate_videos(- self,- videos,- board: "AniposeCharucoBoard",- init_intrinsics=True,- init_extrinsics=True,- verbose=True,- **kwargs,- ):- """Takes as input a list of list of video filenames, one list of each camera.- Also takes a board which specifies what should be detected in the videos"""-- all_rows = self.get_rows_videos(videos, board, verbose=verbose)- if init_extrinsics:- self.set_camera_sizes_videos(videos)-- error, merged, charuco_frames = self.calibrate_rows(- all_rows,- board,- init_intrinsics=init_intrinsics,- init_extrinsics=init_extrinsics,- verbose=verbose,- **kwargs,- )- return error, merged, charuco_frames-- def get_dicts(self):- out = []- for cam in self.cameras:- out.append(cam.get_dict())- return out-- def from_dicts(arr):- cameras = []- for d in arr:- if "fisheye" in d and d["fisheye"]:- cam = FisheyeCamera.from_dict(d)- else:- cam = Camera.from_dict(d)- cameras.append(cam)- return CameraGroup(cameras)-- @staticmethod- def from_names(names, fisheye=False):- cameras = []- for name in names:- if fisheye:- cam = FisheyeCamera(name=name)- else:- cam = Camera(name=name)- cameras.append(cam)- return CameraGroup(cameras)-- def load_dicts(self, arr):- for cam, d in zip(self.cameras, arr):- cam.load_dict(d)-- def dump(self, fname):- dicts = self.get_dicts()- names = ["cam_{}".format(i) for i in range(len(dicts))]- master_dict = dict(zip(names, dicts))- master_dict["metadata"] = self.metadata- with open(fname, "w") as f:- toml.dump(master_dict, f)-- @staticmethod- def load(fname):- master_dict = toml.load(fname)- keys = sorted(master_dict.keys())- items = [master_dict[k] for k in keys if k != "metadata"]- cgroup = CameraGroup.from_dicts(items)- if "metadata" in master_dict:- cgroup.metadata = master_dict["metadata"]- return cgroup-- def resize_cameras(self, scale):- for cam in self.cameras:- cam.resize_camera(scale)---class AniposeCharucoBoard(CharucoBoard):- def __init__(- self,- squaresX,- squaresY,- square_length,- marker_length,- marker_bits=4,- dict_size=50,- aruco_dict=None,- manually_verify=False,- ):- self.squaresX = squaresX- self.squaresY = squaresY- self.square_length = square_length- self.marker_length = marker_length- self.manually_verify = manually_verify- self.marker_bits = marker_bits- self.dict_size = dict_size-- dkey = (marker_bits, dict_size)- self.dictionary = cv2.aruco.getPredefinedDictionary(ARUCO_DICTS[dkey])-- self.board = cv2.aruco.CharucoBoard(- size=[squaresX, squaresY],- squareLength=square_length,- markerLength=marker_length,- dictionary=self.dictionary,- )-- total_size = (squaresX - 1) * (squaresY - 1)-- objp = np.zeros((total_size, 3), np.float64)- objp[:, :2] = np.mgrid[0: (squaresX - 1), 0: (squaresY - 1)].T.reshape(-1, 2)- objp *= square_length- self.objPoints = objp-- self.empty_detection = np.zeros((total_size, 1, 2)) * np.nan- self.total_size = total_size-- def detect_markers(self, image, camera=None, refine=True):- if len(image.shape) == 3:- gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)- else:- gray = image-- params = cv2.aruco.DetectorParameters()- params.cornerRefinementMethod = cv2.aruco.CORNER_REFINE_CONTOUR- params.adaptiveThreshWinSizeMin = 100- params.adaptiveThreshWinSizeMax = 700- params.adaptiveThreshWinSizeStep = 50- params.adaptiveThreshConstant = 0-- try:- corners, ids, rejectedImgPoints = cv2.aruco.detectMarkers(gray, self.dictionary, parameters=params)- except Exception:- ids = None-- if ids is None:- return [], []-- if camera is None:- K = D = None- else:- K = camera.get_camera_matrix()- D = camera.get_distortions()-- if refine:- detectedCorners, detectedIds, rejectedCorners, recoveredIdxs = cv2.aruco.refineDetectedMarkers(- gray, self.board, corners, ids, rejectedImgPoints, K, D, parameters=params- )- else:- detectedCorners, detectedIds = corners, ids-- return detectedCorners, detectedIds-- def detect_image(self, image, camera=None):- if len(image.shape) == 3:- gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)- else:- gray = image-- corners, ids = self.detect_markers(image, camera, refine=True)- if len(corners) > 0:- ret, detectedCorners, detectedIds = cv2.aruco.interpolateCornersCharuco(corners, ids, gray, self.board)- if detectedIds is None:- detectedCorners = detectedIds = np.float64([])- else:- detectedCorners = detectedIds = np.float64([])-- if (- len(detectedCorners) > 0- and self.manually_verify- and not self.manually_verify_board_detection(gray, detectedCorners, detectedIds)- ):- detectedCorners = detectedIds = np.float64([])-- return detectedCorners, detectedIds-- def manually_verify_board_detection(self, image, corners, ids=None):- height, width = image.shape[:2]- image = cv2.aruco.drawDetectedCornersCharuco(image, corners, ids)- cv2.putText(- image,- "(a) Accept (d) Reject",- (int(width / 1.35), int(height / 16)),- cv2.FONT_HERSHEY_SIMPLEX,- 0.5,- 255,- 1,- cv2.LINE_AA,- )- cv2.imshow("verify_detection", image)- while 1:- key = cv2.waitKey(0) & 0xFF- if key == ord("a"):- cv2.putText(- image,- "Accepted!",- (int(width / 2.5), int(height / 1.05)),- cv2.FONT_HERSHEY_SIMPLEX,- 1,- 255,- 2,- cv2.LINE_AA,- )- cv2.imshow("verify_detection", image)- cv2.waitKey(100)- return True- elif key == ord("d"):- cv2.putText(- image,- "Rejected!",- (int(width / 2.5), int(height / 1.05)),- cv2.FONT_HERSHEY_SIMPLEX,- 1,- 255,- 2,- cv2.LINE_AA,- )- cv2.imshow("verify_detection", image)- cv2.waitKey(100)- return False-- def estimate_pose_points(self, camera, corners, ids):- if corners is None or ids is None or len(corners) < 5:- return None, None-- n_corners = corners.size // 2- corners = np.reshape(corners, (n_corners, 1, 2))-- K = camera.get_camera_matrix()- D = camera.get_distortions()-- ret, rvec, tvec = cv2.aruco.estimatePoseCharucoBoard(corners, ids, self.board, K, D, None, None)-- return rvec, tvecdiff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/anipose_camera_calibration/get_anipose_calibration_object.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/anipose_camera_calibration/get_anipose_calibration_object.pydeleted file mode 100644index c04541b1..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/anipose_camera_calibration/get_anipose_calibration_object.py+++ /dev/null@@ -1,70 +0,0 @@-import filecmp-import logging-import shutil-from pathlib import Path-from typing import Union--from freemocap.core_processes.capture_volume_calibration.anipose_camera_calibration import (- freemocap_anipose,-)-from freemocap.system.paths_and_filenames.path_getters import get_last_successful_calibration_toml_path--logger = logging.getLogger(__name__)---def load_most_recent_anipose_calibration_toml(- save_copy_of_calibration_to_this_path: Union[str, Path, None] = None-) -> freemocap_anipose.CameraGroup:- most_recent_calibration_toml_path = get_last_successful_calibration_toml_path()- logger.info(f"loading `most recent calibration from:{str(most_recent_calibration_toml_path)}")- if save_copy_of_calibration_to_this_path is not None:- logger.info(f"Saving copy of `most_recent_calibration.toml` to {save_copy_of_calibration_to_this_path}")-- shutil.copy(- str(most_recent_calibration_toml_path),- str(Path(save_copy_of_calibration_to_this_path) / Path(most_recent_calibration_toml_path).name),- )-- try:- camera_group = freemocap_anipose.CameraGroup.load(str(most_recent_calibration_toml_path))- except Exception as e:- logger.exception(e)- raise- return camera_group---def load_anipose_calibration_toml_from_path(- camera_calibration_data_toml_path: Union[str, Path],- save_copy_of_calibration_to_this_path: Union[str, Path, None] = None,-) -> freemocap_anipose.CameraGroup:- logger.info(f"loading camera calibration file from:{str(camera_calibration_data_toml_path)}")- try:- anipose_calibration_object = freemocap_anipose.CameraGroup.load(str(camera_calibration_data_toml_path))- if save_copy_of_calibration_to_this_path is not None:- copy_toml_path = str(- Path(save_copy_of_calibration_to_this_path) / Path(camera_calibration_data_toml_path).name- )-- if Path(copy_toml_path).is_file() and not filecmp.cmp(- str(camera_calibration_data_toml_path), copy_toml_path- ):- logger.info(- f"Saving copy of {camera_calibration_data_toml_path} to {save_copy_of_calibration_to_this_path}"- )- shutil.copyfile(str(camera_calibration_data_toml_path), copy_toml_path)-- return anipose_calibration_object- except Exception as e:- logger.error(f"Failed to load anipose calibration info from {str(camera_calibration_data_toml_path)}")- raise e---def load_calibration_from_session_id(- session_calibration_file_path: Union[str, Path],-) -> freemocap_anipose.CameraGroup:- logger.info(f"loading camera calibration file from:{str(session_calibration_file_path)}")- try:- return freemocap_anipose.CameraGroup.load(str(session_calibration_file_path))- except Exception as e:- logger.error(f"Failed to load anipose calibration info from {str(session_calibration_file_path)}")- raise ediff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/by_camera_reprojection_filtering.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/by_camera_reprojection_filtering.pydeleted file mode 100644index b4cd5ab2..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/by_camera_reprojection_filtering.py+++ /dev/null@@ -1,283 +0,0 @@-import logging-from pathlib import Path-from typing import Tuple, Union--import numpy as np-from freemocap.core_processes.capture_volume_calibration.save_3d_data_to_npy import (- save_3d_data_to_npy,-)-from freemocap.core_processes.capture_volume_calibration.triangulate_3d_data import triangulate_3d_data-from freemocap.data_layer.recording_models.post_processing_parameter_models import ProcessingParameterModel-from matplotlib import pyplot as plt--logger = logging.getLogger(__name__)---def run_reprojection_error_filtering(- image_data_numCams_numFrames_numTrackedPts_XYZ: np.ndarray,- raw_skel3d_frame_marker_xyz: np.ndarray,- skeleton_reprojection_error_cam_fr_mar: np.ndarray,- skeleton_reprojection_error_fr_mar: np.ndarray,- anipose_calibration_object,- processing_parameters: ProcessingParameterModel,-) -> np.ndarray:- """- Runs reprojection error filtering on 3d data, saves the filtered 3d data and reprojection error data, and creates and saves a debug plot.-- :param image_data_numCams_numFrames_numTrackedPts_XYZ: original 2d data- :param raw_skel3d_frame_marker_xyz: original 3d data- :param skeleton_reprojection_error_cam_fr_mar: original per camerareprojection error- :param skeleton_reprojection_error_fr_mar: original per frame average reprojection error- :param anipose_calibration_object: anipose calibration object- :param processing_parameters: processing parameters-- :return: filtered 3d data- """- if hasattr(- processing_parameters.tracking_model_info, "num_tracked_points_body"- ): # we don't want to reproject hand and face data- num_tracked_points = processing_parameters.tracking_model_info.num_tracked_points_body- else:- num_tracked_points = processing_parameters.tracking_model_info.num_tracked_points-- (- reprojection_filtered_skel3d_frame_marker_xyz,- reprojection_filtered_skeleton_reprojection_error_fr_mar,- reprojection_filtered_skeleton_reprojection_error_cam_fr_mar,- ) = filter_by_reprojection_error(- reprojection_error_camera_frame_marker=skeleton_reprojection_error_cam_fr_mar,- reprojection_error_frame_marker=skeleton_reprojection_error_fr_mar,- reprojection_error_confidence_threshold=processing_parameters.anipose_triangulate_3d_parameters_model.reprojection_error_confidence_cutoff,- image_2d_data=image_data_numCams_numFrames_numTrackedPts_XYZ[:, :, :, :2],- raw_skel3d_frame_marker_xyz=raw_skel3d_frame_marker_xyz,- anipose_calibration_object=anipose_calibration_object,- num_tracked_points=num_tracked_points,- use_triangulate_ransac=processing_parameters.anipose_triangulate_3d_parameters_model.use_triangulate_ransac_method,- minimum_cameras_to_reproject=processing_parameters.anipose_triangulate_3d_parameters_model.minimum_cameras_to_reproject,- )- save_3d_data_to_npy(- data3d_numFrames_numTrackedPoints_XYZ=reprojection_filtered_skel3d_frame_marker_xyz,- data3d_numFrames_numTrackedPoints_reprojectionError=reprojection_filtered_skeleton_reprojection_error_fr_mar,- data3d_numCams_numFrames_numTrackedPoints_reprojectionError=reprojection_filtered_skeleton_reprojection_error_cam_fr_mar,- path_to_folder_where_data_will_be_saved=processing_parameters.recording_info_model.raw_data_folder_path,- processing_level="reprojection_filtered",- file_prefix=processing_parameters.tracking_model_info.name,- )- plot_reprojection_error(- raw_reprojection_error_frame_marker=skeleton_reprojection_error_fr_mar,- filtered_reprojection_error_frame_marker=reprojection_filtered_skeleton_reprojection_error_fr_mar,- reprojection_error_threshold=float(- np.nanpercentile(- skeleton_reprojection_error_cam_fr_mar,- processing_parameters.anipose_triangulate_3d_parameters_model.reprojection_error_confidence_cutoff,- )- ),- output_folder_path=processing_parameters.recording_info_model.raw_data_folder_path,- )- return reprojection_filtered_skel3d_frame_marker_xyz---def filter_by_reprojection_error(- reprojection_error_camera_frame_marker: np.ndarray,- reprojection_error_frame_marker: np.ndarray,- reprojection_error_confidence_threshold: float,- image_2d_data: np.ndarray,- raw_skel3d_frame_marker_xyz: np.ndarray,- anipose_calibration_object,- num_tracked_points: int,- use_triangulate_ransac: bool = False,- minimum_cameras_to_reproject: int = 3,-) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:- total_cameras = image_2d_data.shape[0]- num_cameras_to_remove = 1-- if total_cameras <= minimum_cameras_to_reproject:- logger.warning(- f"Not enough cameras to filter by reprojection error. There are {total_cameras} cameras, but minimum number of cameras is {minimum_cameras_to_reproject}. Returning unfiltered data."- )- return (- raw_skel3d_frame_marker_xyz,- reprojection_error_frame_marker,- reprojection_error_camera_frame_marker,- )-- body2d_camera_frame_marker_xy = image_2d_data[:, :, :num_tracked_points, :2]- bodyReprojErr_camera_frame_marker = reprojection_error_camera_frame_marker[:, :, :num_tracked_points]-- reprojection_error_confidence_threshold = min(max(reprojection_error_confidence_threshold, 0), 100)-- reprojection_error_threshold = np.nanpercentile(- np.nanmean(bodyReprojErr_camera_frame_marker, axis=0), reprojection_error_confidence_threshold, method="weibull"- ) # TODO: try running this on reprojection_error_frame_marker with body points pulled out, rather than with cameras included- logger.info(f"Using reprojection error threshold of {reprojection_error_threshold}")-- data_to_reproject_camera_frame_marker_xy, unique_frame_marker_list = _get_data_to_reproject(- num_cameras_to_remove=num_cameras_to_remove,- reprojection_error_threshold=reprojection_error_threshold,- reprojError_cam_frame_marker=bodyReprojErr_camera_frame_marker,- input_2d_data_camera_frame_marker_xy=body2d_camera_frame_marker_xy,- )-- while len(unique_frame_marker_list) > 0 and total_cameras - num_cameras_to_remove >= minimum_cameras_to_reproject:- logger.info("Retriangulating data")- (- retriangulated_data_frame_marker_xyz,- new_reprojection_error_flat,- new_reprojError_cam_frame_marker,- ) = triangulate_3d_data(- anipose_calibration_object=anipose_calibration_object,- image_2d_data=data_to_reproject_camera_frame_marker_xy,- use_triangulate_ransac=use_triangulate_ransac,- )-- num_cameras_to_remove += 1-- data_to_reproject_camera_frame_marker_xy, unique_frame_marker_list = _get_data_to_reproject(- num_cameras_to_remove=num_cameras_to_remove,- reprojection_error_threshold=reprojection_error_threshold,- reprojError_cam_frame_marker=new_reprojError_cam_frame_marker,- input_2d_data_camera_frame_marker_xy=data_to_reproject_camera_frame_marker_xy,- )-- # nan remaining data above threshold- _nan_data_above_threshold(unique_frame_marker_list, retriangulated_data_frame_marker_xyz)-- # put retriangulated data back in place- filtered_skel3d_frame_marker_xyz = raw_skel3d_frame_marker_xyz.copy()- filtered_skel3d_frame_marker_xyz[:, :num_tracked_points, :] = retriangulated_data_frame_marker_xyz-- filtered_reprojection_error_frame_marker = reprojection_error_frame_marker.copy()- filtered_reprojection_error_frame_marker[:, :num_tracked_points] = new_reprojection_error_flat-- filtered_reprojection_error_camera_frame_marker = reprojection_error_camera_frame_marker.copy()- filtered_reprojection_error_camera_frame_marker[:, :, :num_tracked_points] = new_reprojError_cam_frame_marker-- return (- filtered_skel3d_frame_marker_xyz,- filtered_reprojection_error_frame_marker,- filtered_reprojection_error_camera_frame_marker,- )---def _nan_data_above_threshold(unique_frame_marker_list: list, retriangulated_data_frame_marker_xyz: np.ndarray) -> None:- if len(unique_frame_marker_list) > 0:- logger.info(- f"Out of cameras to remove, setting {len(unique_frame_marker_list)} points with reprojection error above threshold to NaNs"- )- for frame_marker in unique_frame_marker_list:- retriangulated_data_frame_marker_xyz[frame_marker[0], frame_marker[1], :] = np.nan---def _get_data_to_reproject(- num_cameras_to_remove: int,- reprojection_error_threshold: float,- reprojError_cam_frame_marker: np.ndarray,- input_2d_data_camera_frame_marker_xy: np.ndarray,-) -> tuple[np.ndarray, list]:- indices_above_threshold = np.nonzero(reprojError_cam_frame_marker > reprojection_error_threshold)- logger.debug(f"SHAPE OF INDICES ABOVE THRESHOLD: {indices_above_threshold[0].shape}")-- total_frame_marker_combos = (- input_2d_data_camera_frame_marker_xy.shape[1] * input_2d_data_camera_frame_marker_xy.shape[2]- )- unique_frame_marker_list = _get_unique_frame_marker_list(indices_above_threshold=indices_above_threshold)- logger.info(- f"number of frame/marker combos with reprojection error above threshold: {len(unique_frame_marker_list)} ({len(unique_frame_marker_list) / total_frame_marker_combos * 100:.1f} percent of total)"- )-- cameras_to_remove, frames_to_reproject, markers_to_reproject = _get_camera_frame_marker_lists_to_reproject(- reprojError_cam_frame_marker=reprojError_cam_frame_marker,- frame_marker_list=unique_frame_marker_list,- num_cameras_to_remove=num_cameras_to_remove,- )-- data_to_reproject_camera_frame_marker_xy = _set_unincluded_data_to_nans(- input_2d_data=input_2d_data_camera_frame_marker_xy,- frames_with_reprojection_error=frames_to_reproject,- markers_with_reprojection_error=markers_to_reproject,- cameras_to_remove=cameras_to_remove,- )-- return (data_to_reproject_camera_frame_marker_xy, unique_frame_marker_list)---def _get_unique_frame_marker_list(- indices_above_threshold: np.ndarray,-) -> list:- return list(set(zip(indices_above_threshold[1], indices_above_threshold[2])))---def _get_camera_frame_marker_lists_to_reproject(- reprojError_cam_frame_marker: np.ndarray,- frame_marker_list: list,- num_cameras_to_remove: int,-) -> Tuple[list, list, list]:- """- Generate the lists of cameras, frames, and markers to reproject based on the given input.- Find the cameras with the worst reprojection errors for the given frames and markers.- Args:- reprojError_cam_frame_marker (np.ndarray): The array containing the reprojection errors for each camera, frame, and marker.- frame_marker_list (list): The list of tuples containing the frame and marker indices.- num_cameras_to_remove (int): The number of cameras to remove.- Returns:- Tuple[list, list, list]: A tuple containing the lists of cameras to remove, frames to reproject, and markers to reproject.- """- cameras_to_remove = []- frames_to_reproject = []- markers_to_reproject = []- for frame, marker in frame_marker_list:- frames_to_reproject.append(frame)- markers_to_reproject.append(marker)- max_indices = reprojError_cam_frame_marker[:, frame, marker].argsort()[::-1][:num_cameras_to_remove]- cameras_to_remove.append(list(max_indices))- return (cameras_to_remove, frames_to_reproject, markers_to_reproject)---def _set_unincluded_data_to_nans(- input_2d_data: np.ndarray,- frames_with_reprojection_error: list,- markers_with_reprojection_error: list,- cameras_to_remove: list[list[int]],-) -> np.ndarray:- data_to_reproject = input_2d_data.copy()- for list_of_cameras, frame, marker in zip(- cameras_to_remove, frames_with_reprojection_error, markers_with_reprojection_error- ):- for camera in list_of_cameras:- data_to_reproject[camera, frame, marker, :] = np.nan- return data_to_reproject---def plot_reprojection_error(- raw_reprojection_error_frame_marker: np.ndarray,- filtered_reprojection_error_frame_marker: np.ndarray,- reprojection_error_threshold: float,- output_folder_path: Union[str, Path],-) -> None:- title = "Mean Reprojection Error Per Frame"- file_name = "debug_reprojection_error_filtering.png"- output_filepath = Path(output_folder_path) / file_name- raw_mean_reprojection_error_per_frame = np.nanmean(- raw_reprojection_error_frame_marker,- axis=1,- )- filtered_mean_reprojection_error_per_frame = np.nanmean(- filtered_reprojection_error_frame_marker,- axis=1,- )- plt.plot(raw_mean_reprojection_error_per_frame, color="blue", label="Data Before Filtering")- plt.plot(filtered_mean_reprojection_error_per_frame, color="orange", alpha=0.9, label="Data After Filtering")- plt.xlabel("Frame")- plt.ylabel("Mean Reprojection Error Across Markers (mm)")- plt.ylim(0, 2 * reprojection_error_threshold)- plt.hlines(- y=reprojection_error_threshold,- xmin=0,- xmax=len(raw_mean_reprojection_error_per_frame),- color="red",- label="Cutoff Threshold",- )- plt.title(title)- plt.legend(loc="upper right")- logger.info(f"Saving debug plots to: {output_filepath}")- plt.savefig(output_filepath, dpi=300)diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/charuco_stuff/__init__.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/charuco_stuff/__init__.pydeleted file mode 100644index e69de29b..00000000diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/charuco_stuff/charuco_board_definition.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/charuco_stuff/charuco_board_definition.pydeleted file mode 100644index 46590ca6..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/charuco_stuff/charuco_board_definition.py+++ /dev/null@@ -1,51 +0,0 @@-from dataclasses import dataclass-from typing import Dict--import cv2---@dataclass-class CharucoBoardDefinition:- name: str- number_of_squares_width: int- number_of_squares_height: int- black_square_side_length: float = 1.0- aruco_marker_length_proportional: float = 0.8- aruco_marker_dict: Dict = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_4X4_50)-- def __post_init__(self):- self.charuco_board = cv2.aruco.CharucoBoard(- size=[self.number_of_squares_width, self.number_of_squares_height],- squareLength=self.black_square_side_length,- markerLength=self.aruco_marker_length_proportional,- dictionary=self.aruco_marker_dict,- )-- self.number_of_charuco_corners = (self.number_of_squares_width - 1) * (self.number_of_squares_height - 1)---def charuco_7x5() -> CharucoBoardDefinition:- return CharucoBoardDefinition(- name="7x5 Charuco",- number_of_squares_width=7,- number_of_squares_height=5,- black_square_side_length=1,- aruco_marker_length_proportional=0.8,- )---def charuco_5x3() -> CharucoBoardDefinition:- return CharucoBoardDefinition(- name="5x3 Charuco",- number_of_squares_width=5,- number_of_squares_height=3,- black_square_side_length=1,- aruco_marker_length_proportional=0.8,- )---CHARUCO_BOARD_IMAGES_URL = "https://github.com/freemocap/freemocap/blob/main/freemocap/assets/charuco/"-CHARUCO_BOARDS = {- "7x5 Charuco": charuco_7x5,- "5x3 Charuco": charuco_5x3,-}diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/run_anipose_capture_volume_calibration.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/run_anipose_capture_volume_calibration.pydeleted file mode 100644index be90185f..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/run_anipose_capture_volume_calibration.py+++ /dev/null@@ -1,35 +0,0 @@-import threading-from pathlib import Path-from typing import Callable, Union--from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.v1_capture_volume_calibration.anipose_camera_calibration.anipose_camera_calibrator import \- GroundPlaneSuccess, AniposeCameraCalibrator-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.v1_capture_volume_calibration.charuco_stuff.charuco_board_definition import \- CharucoBoardDefinition---async def async_run_anipose_capture_volume_calibration(**kwargs):- run_anipose_capture_volume_calibration(**kwargs)---def run_anipose_capture_volume_calibration(- charuco_board_definition: CharucoBoardDefinition,- charuco_square_size: float,- calibration_recording_folder: Union[str, Path],- kill_event: threading.Event,- pin_camera_0_to_origin: bool = True,- use_charuco_as_groundplane: bool = True,- progress_callback: Callable[[str], None] = lambda _: None,-) -> tuple[Path, GroundPlaneSuccess]:- anipose_camera_calibrator = AniposeCameraCalibrator(- charuco_board_object=charuco_board_definition,- charuco_square_size=charuco_square_size,- calibration_recording_folder=calibration_recording_folder,- progress_callback=progress_callback,- )- toml_path, groundplane_success = anipose_camera_calibrator.calibrate_camera_capture_volume(- pin_camera_0_to_origin=pin_camera_0_to_origin,- use_charuco_as_groundplane=use_charuco_as_groundplane- )-- return toml_path, groundplane_successdiff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/save_3d_data_to_npy.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/save_3d_data_to_npy.pydeleted file mode 100644index 5116e9c9..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/save_3d_data_to_npy.py+++ /dev/null@@ -1,66 +0,0 @@-import logging-from pathlib import Path-from typing import Union--import numpy as np-from freemocap.system.paths_and_filenames.file_and_folder_names import (- RAW_3D_NPY_FILE_NAME,- FULL_REPROJECTION_ERROR_NPY_FILE_NAME,- REPROJECTION_ERROR_NPY_FILE_NAME,- REPROJECTION_FILTERED_PREFIX,-)--logger = logging.getLogger(__name__)---def save_3d_data_to_npy(- data3d_numFrames_numTrackedPoints_XYZ: np.ndarray,- data3d_numFrames_numTrackedPoints_reprojectionError: np.ndarray,- data3d_numCams_numFrames_numTrackedPoints_reprojectionError: np.ndarray,- path_to_folder_where_data_will_be_saved: Union[str, Path],- processing_level: str,- file_prefix: str = "",-):- path_to_folder_where_data_will_be_saved = Path(path_to_folder_where_data_will_be_saved)- Path(path_to_folder_where_data_will_be_saved).mkdir(parents=True, exist_ok=True) # save spatial XYZ data- if processing_level == "raw":- data_3d_save_path = path_to_folder_where_data_will_be_saved / f"{file_prefix}_{RAW_3D_NPY_FILE_NAME}"- reprojection_error_save_path = (- path_to_folder_where_data_will_be_saved / f"{file_prefix}_{REPROJECTION_ERROR_NPY_FILE_NAME}"- )- full_reprojection_error_save_path = (- path_to_folder_where_data_will_be_saved / f"{file_prefix}_{FULL_REPROJECTION_ERROR_NPY_FILE_NAME}"- )- elif processing_level == "reprojection_filtered":- data_3d_save_path = (- path_to_folder_where_data_will_be_saved- / f"{REPROJECTION_FILTERED_PREFIX}{file_prefix}_{RAW_3D_NPY_FILE_NAME}"- )- reprojection_error_save_path = (- path_to_folder_where_data_will_be_saved- / f"{REPROJECTION_FILTERED_PREFIX}{file_prefix}_{REPROJECTION_ERROR_NPY_FILE_NAME}"- )- full_reprojection_error_save_path = (- path_to_folder_where_data_will_be_saved- / f"{REPROJECTION_FILTERED_PREFIX}{file_prefix}_{FULL_REPROJECTION_ERROR_NPY_FILE_NAME}"- )- else:- logger.exception(f"processing_level: {processing_level} not recognized")- raise Exception-- logger.info(f"saving: {data_3d_save_path}")- np.save(str(data_3d_save_path), data3d_numFrames_numTrackedPoints_XYZ)-- # save reprojection error-- logger.info(f"saving: {reprojection_error_save_path}")- np.save(- str(reprojection_error_save_path),- data3d_numFrames_numTrackedPoints_reprojectionError,- )-- logger.info(f"saving: {full_reprojection_error_save_path}")- np.save(- str(full_reprojection_error_save_path),- data3d_numCams_numFrames_numTrackedPoints_reprojectionError,- )diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/triangulate_3d_data.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/triangulate_3d_data.pydeleted file mode 100644index cff78069..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/v1_capture_volume_calibration/triangulate_3d_data.py+++ /dev/null@@ -1,151 +0,0 @@-import logging-import multiprocessing-from pathlib import Path--import numpy as np-from freemocap.core_processes.capture_volume_calibration.anipose_camera_calibration.freemocap_anipose import CameraGroup-from freemocap.core_processes.capture_volume_calibration.save_3d_data_to_npy import (- save_3d_data_to_npy,-)--logger = logging.getLogger(__name__)---def triangulate_3d_data(- anipose_calibration_object: CameraGroup,- image_2d_data: np.ndarray,- use_triangulate_ransac: bool = False,- kill_event: multiprocessing.Event = None,-) -> tuple[np.ndarray, np.ndarray, np.ndarray]:- number_of_cameras = image_2d_data.shape[0]- number_of_frames = image_2d_data.shape[1]- number_of_tracked_points = image_2d_data.shape[2]- number_of_spatial_dimensions = image_2d_data.shape[3]-- if not number_of_spatial_dimensions == 2:- logger.error(- f"This is supposed to be 2D data but, number_of_spatial_dimensions: {number_of_spatial_dimensions}"- )- raise ValueError-- # reshape data to collapse across 'frames' so it becomes [number_of_cameras,- # number_of_2d_points(numFrames*numPoints), XY]- data2d_flat = image_2d_data.reshape(number_of_cameras, -1, 2)-- logger.info(- f"Reconstructing 3d points from 2d points with shape: \n"- f"number_of_cameras: {number_of_cameras},\n"- f"number_of_frames: {number_of_frames}, \n"- f"number_of_tracked_points: {number_of_tracked_points},\n"- f"number_of_spatial_dimensions: {number_of_spatial_dimensions}"- )-- if use_triangulate_ransac:- logger.info("Using `triangulate_ransac` method")- data3d_flat = anipose_calibration_object.triangulate_ransac(data2d_flat, progress=True, kill_event=kill_event)- else:- logger.info("Using simple `triangulate` method ")- data3d_flat = anipose_calibration_object.triangulate(data2d_flat, progress=True, kill_event=kill_event)-- spatial_data3d_numFrames_numTrackedPoints_XYZ = data3d_flat.reshape(number_of_frames, number_of_tracked_points, 3)-- data3d_reprojectionError_flat = anipose_calibration_object.reprojection_error(data3d_flat, data2d_flat, mean=True)- data3d_reprojectionError_full = anipose_calibration_object.reprojection_error(data3d_flat, data2d_flat, mean=False)- reprojectionError_cam_frame_marker = np.linalg.norm(data3d_reprojectionError_full, axis=2).reshape(- number_of_cameras, number_of_frames, number_of_tracked_points- )-- reprojection_error_data3d_numFrames_numTrackedPoints = data3d_reprojectionError_flat.reshape(- number_of_frames, number_of_tracked_points- )-- return (- spatial_data3d_numFrames_numTrackedPoints_XYZ,- reprojection_error_data3d_numFrames_numTrackedPoints,- reprojectionError_cam_frame_marker,- )---if __name__ == "__main__":- from freemocap.core_processes.capture_volume_calibration.anipose_camera_calibration.get_anipose_calibration_object import (- load_anipose_calibration_toml_from_path,- )- import argparse-- parser = argparse.ArgumentParser()- parser.add_argument(- "--data_2d_path",- type=str,- help="path to 2d data",- required=True,- )- parser.add_argument(- "--output_data_folder_path",- type=str,- help="path to output folder",- required=False,- )- parser.add_argument(- "--calibration_file_path",- type=str,- help="path to calibration file",- required=False,- )- parser.add_argument(- "--save_data_as_csv",- type=bool,- help="save data as csv",- required=False,- )- parser.add_argument(- "--use_triangulate_ransac",- type=bool,- help="use triangulate ransac anipose method ",- required=False,- )- parser.add_argument(- "--file_prefix",- type=str,- help="file prefix",- required=False,- )- args = parser.parse_args()-- data_2d = np.load(args.data_2d_path)-- if args.output_data_folder_path is None:- args.output_data_folder_path = Path(args.data_2d_path).parent-- if args.save_data_as_csv is None:- args.save_data_as_csv = True # default-- if args.use_triangulate_ransac is None:- args.use_triangulate_ransac = True-- if args.file_prefix is None:- args.file_prefix = ""-- if args.calibration_file_path:- anipose_calibration_object = load_anipose_calibration_toml_from_path(args.calibration_file_path)- else:- anipose_calibration_object = load_anipose_calibration_toml_from_path(- Path(args.data_2d_path).parent.parent / "camera_calibration_data.toml"- )-- (- skel3d_frame_marker_xyz,- skeleton_reprojection_error_fr_mar,- skeleton_reprojection_error_cam_fr_mar,- ) = triangulate_3d_data(- anipose_calibration_object=anipose_calibration_object,- image_2d_data=data_2d,- use_triangulate_ransac=args.use_triangulate_ransac,- )- save_3d_data_to_npy(- data3d_numFrames_numTrackedPoints_XYZ=skel3d_frame_marker_xyz,- data3d_numFrames_numTrackedPoints_reprojectionError=skeleton_reprojection_error_fr_mar,- data3d_numCams_numFrames_numTrackedPoints_reprojectionError=skeleton_reprojection_error_cam_fr_mar,- path_to_folder_where_data_will_be_saved=args.output_data_folder_path,- processing_level="raw",- file_prefix=args.file_prefix,- )diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/shared_view_accumulator.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/shared_view_accumulator.pydeleted file mode 100644index 29c8e7bc..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/shared_view_accumulator.py+++ /dev/null@@ -1,188 +0,0 @@-import logging--from pydantic import BaseModel, Field-from pydantic import model_validator-from skellycam.core.types.type_overloads import CameraIdString, FrameNumberInt-from skellytracker.trackers.charuco_tracker.charuco_observation import CharucoObservation--from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.calibration_task.ooooold.calibration_helpers.calibration_numpy_types import ImagePoint2D-from freemocap.pubsub.pubsub_topics import CameraNodeOutputMessage--CharucoObservations = dict[CameraIdString, CharucoObservation | None]--MultiFrameNumber = int-MINIMUM_CHARUCO_CORNERS_FOR_VISIBILITY: int = 6-logger = logging.getLogger(__name__)---class CameraPair(BaseModel):- base_camera_id: CameraIdString- other_camera_id: CameraIdString-- @classmethod- def from_ids(cls, *, base_camera_id: CameraIdString, other_camera_id: CameraIdString):- return cls(base_camera_id=base_camera_id,- other_camera_id=other_camera_id)-- @model_validator(mode='after')- def validate(self):- if self.base_camera_id == self.other_camera_id:- raise ValueError("base_camera_id and other_camera_id must be different")- return self-- def __eq__(self, other):- if isinstance(other, CameraPair):- return self.model_dump() == other.model_dump()- return False-- def __hash__(self):- return hash(self.model_dump_json())---class CameraPairTargetView(BaseModel):- multi_frame_number: MultiFrameNumber- base_camera_id: CameraIdString- other_camera_id: CameraIdString- base_camera_observation: CharucoObservation- other_camera_observation: CharucoObservation-- @model_validator(mode='after')- def validate(self):- if self.base_camera_id == self.other_camera_id:- raise ValueError("base_camera_id and other_camera_id must be different")- if self.base_camera_observation.frame_number != self.multi_frame_number:- logger.warning(- f"base_camera_observation frame_number {self.base_camera_observation.frame_number} does not match multi_frame_number {self.multi_frame_number}")- if self.other_camera_observation.frame_number != self.multi_frame_number:- logger.warning(- f"other_camera_observation frame_number {self.other_camera_observation.frame_number} does not match multi_frame_number {self.multi_frame_number}")- return self---class MultiCameraTargetView(BaseModel):- multi_frame_number: MultiFrameNumber- camera_node_output_by_camera: dict[CameraIdString, CameraNodeOutputMessage]-- @model_validator(mode='after')- def validate(self):- if not all([output.frame_number == self.multi_frame_number for output in- self.camera_node_output_by_camera.values()]):- logger.warning(- f"multi_frame_number {self.multi_frame_number} does not match all camera_node_output_by_camera multi_frame_numbers: {[output.frame_number for output in self.camera_node_output_by_camera.values()]}")- return self-- @property- def target_visibility_by_camera(self) -> dict[CameraIdString, bool]:- visibility_by_camera = {}- for camera_id, camera_node_output in self.camera_node_output_by_camera.items():- visibility_by_camera[camera_id] = len(- camera_node_output.observation.charuco_corners_dict) > MINIMUM_CHARUCO_CORNERS_FOR_VISIBILITY- return visibility_by_camera-- @property- def image_points_by_camera(self) -> dict[CameraIdString, list[ImagePoint2D]]:- image_points_by_camera = {camera_id: [] for camera_id in self.camera_node_output_by_camera.keys()}- for camera_id, camera_node_output in self.camera_node_output_by_camera.items():- image_points_by_camera[camera_id].extend(- list(camera_node_output.observation.detected_charuco_corners_in_full_array))-- return image_points_by_camera---class SharedViewAccumulator(BaseModel):- camera_ids: list[CameraIdString]- multi_camera_views_by_frame: dict[FrameNumberInt, MultiCameraTargetView] = Field(default_factory=dict)- camera_shared_views: dict[CameraIdString, dict[CameraPair, list[CameraPairTargetView]]]-- @classmethod- def create(cls, camera_ids: list[CameraIdString]):- camera_shared_views: dict[CameraIdString, dict[CameraPair, list[CameraPairTargetView]]] = {}- for camera_id in camera_ids:- for other_camera_id in camera_ids:- if camera_id == other_camera_id:- continue- if camera_id not in camera_shared_views:- camera_shared_views[camera_id] = {}- pair = CameraPair.from_ids(base_camera_id=camera_id,- other_camera_id=other_camera_id)- camera_shared_views[camera_id][pair] = []- return cls(camera_ids=camera_ids,- camera_shared_views=camera_shared_views)-- def receive_camera_node_output(- self,- multi_frame_number: int,- camera_node_output_by_camera: dict[CameraIdString, CameraNodeOutputMessage]- ):- if multi_frame_number in self.multi_camera_views_by_frame:- raise RuntimeError(f"Received duplicate camera node outputs for frame {multi_frame_number}")-- if set(camera_node_output_by_camera.keys()) != set(self.camera_ids):- raise ValueError(- f"camera_node_output_by_camera keys {camera_node_output_by_camera.keys()} do not match expected camera ids {self.camera_ids}")-- self.multi_camera_views_by_frame[multi_frame_number] = MultiCameraTargetView(- multi_frame_number=multi_frame_number,- camera_node_output_by_camera=camera_node_output_by_camera- )-- # accumulate shared target views for each camera pair- for camera_id in self.camera_shared_views.keys():- if not camera_node_output_by_camera[camera_id].observation.charuco_board_visible:- continue- this_camera_obs = camera_node_output_by_camera[camera_id].observation- for other_camera_id in self.camera_shared_views.keys():- if camera_id == other_camera_id:- continue- if not camera_node_output_by_camera[other_camera_id].observation.charuco_board_visible:- continue- other_camera_obs = camera_node_output_by_camera[other_camera_id].observation- pair = CameraPair.from_ids(base_camera_id=camera_id,- other_camera_id=other_camera_id)- target_view = CameraPairTargetView(- multi_frame_number=multi_frame_number,- base_camera_id=pair.base_camera_id,- other_camera_id=pair.other_camera_id,- base_camera_observation=this_camera_obs,- other_camera_observation=other_camera_obs- )- self.camera_shared_views[camera_id][pair].append(target_view)-- def get_shared_view_count_per_camera(self) -> dict[CameraIdString, int]:- """- Get the number of shared views for each camera id, i.e. the number of frames where the camera can see the target and at least one other camera can also see the target- """- # special case for single camera - all views with target visible are shared views- if len(self.camera_ids) == 1:- single_camera_id = self.camera_ids[0]- visible_view_count = sum(1 for multi_camera_view in self.multi_camera_views_by_frame.values()- if multi_camera_view.target_visibility_by_camera[single_camera_id])- return {single_camera_id: visible_view_count}- camera_shared_view_count = {camera_id: 0 for camera_id in self.camera_ids}- for camera_id, pair_dict in self.camera_shared_views.items():- for pair, target_views in pair_dict.items():- camera_shared_view_count[camera_id] += len(target_views)-- return camera_shared_view_count-- def all_cameras_have_min_shared_views(self, min_shared_views: int = 500) -> bool:- """- find the total number of shared views for each camera id within the various camera pairs- we don't need all possible pairs to have min_shared_views, just that each camera has min_shared_views with at least one other camera- """- return all([count >= min_shared_views for count in self.get_shared_view_count_per_camera().values()])-- def get_observations_by_camera(self, camera_id: CameraIdString) -> dict[FrameNumberInt, CharucoObservation]:- """- Get the charuco observations for a given camera id across all frames- """- observations_by_frame = {}- for multi_frame_number, multi_camera_view in self.multi_camera_views_by_frame.items():- camera_node_output = multi_camera_view.camera_node_output_by_camera[camera_id]- observations_by_frame[multi_frame_number] = camera_node_output.observation- return observations_by_frame---if __name__ == "__main__":- mca = SharedViewAccumulator.create(["CamA", "CamB", "CamC", "CamD"])- print(mca.model_dump_json(indent=2))diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/mocap_task/__init__.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/mocap_task/__init__.pydeleted file mode 100644index d708065f..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/mocap_task/__init__.py+++ /dev/null@@ -1 +0,0 @@-from .__mocap_pipeline import MocapPipeline, MocapPipelineConfigdiff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/mocap_task/__mocap_pipeline.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/mocap_task/__mocap_pipeline.pydeleted file mode 100644index 9303a9ab..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/mocap_task/__mocap_pipeline.py+++ /dev/null@@ -1,95 +0,0 @@-import logging-import multiprocessing-from dataclasses import dataclass-from multiprocessing import Queue-from typing import Dict--from skellycam.core.camera_group.camera.config.camera_config import CameraConfigs-from skellycam.core.camera_group.shmorchestrator.shared_memory.single_slot_camera_group_shared_memory import \- CameraSharedMemoryDTOs-from skellycam.core.frames.payloads.multi_frame_payload import MultiFramePayload-from skellytracker.trackers.mediapipe_tracker import MediapipeTrackerConfig-from skellytracker.trackers.mediapipe_tracker.mediapipe_annotator import MediapipeImageAnnotator, \- MediapipeAnnotatorConfig--from freemocap.core.pipeline.processing_pipeline import BasePipelineConfig, PipelineImageAnnotator, \- BaseProcessingPipeline-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.mocap_task.mocap_aggregation_node import MocapAggregationNodeConfig, \- MocapPipelineOutputData, MocapAggregationProcessNode-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.mocap_task.mocap_camera_node import MocapPipelineCameraNodeConfig, MocapCameraNode--logger = logging.getLogger(__name__)---@dataclass-class MocapPipelineConfig(BasePipelineConfig):- camera_node_configs: dict[CameraId, MocapPipelineCameraNodeConfig]- aggregation_node_config: MocapAggregationNodeConfig-- @classmethod- def create(cls, camera_configs: CameraConfigs, tracker_config: MediapipeTrackerConfig):- return cls(camera_node_configs={camera_id: MocapPipelineCameraNodeConfig(camera_config=camera_config,- tracker_config=tracker_config)- for camera_id, camera_config in camera_configs.items()},- aggregation_node_config=MocapAggregationNodeConfig())---class MocapPipelineImageAnnotator(PipelineImageAnnotator):- camera_node_annotators: dict[CameraId, MediapipeImageAnnotator]-- @classmethod- def create(cls, configs: dict[CameraId, MediapipeAnnotatorConfig]):- return cls(camera_node_annotators={camera_id: MediapipeImageAnnotator.create(config=config)- for camera_id, config in configs.items()}- )-- def annotate_images(self, multiframe_payload: MultiFramePayload,- pipeline_output: MocapPipelineOutputData) -> MultiFramePayload:- for camera_id, annotator in self.camera_node_annotators.items():- multiframe_payload.frames[camera_id].image = annotator.annotate_image(- image=multiframe_payload.frames[camera_id].image,- latest_observation=pipeline_output.camera_node_output[camera_id].mediapipe_observation)- return multiframe_payload---class MocapPipeline(BaseProcessingPipeline):- config: MocapPipelineConfig- camera_nodes: Dict[CameraId, MocapCameraNode]- aggregation_node: MocapAggregationProcessNode- annotator: MocapPipelineImageAnnotator-- @classmethod- def create(cls,- config: MocapPipelineConfig,- camera_shm_dtos: CameraSharedMemoryDTOs,- shutdown_event: multiprocessing.Event):- if not all(camera_id in camera_shm_dtos.keys() for camera_id in config.camera_node_configs.keys()):- raise ValueError("Camera IDs provided in config not in camera shared memory DTOS!")- camera_output_queues = {camera_id: Queue() for camera_id in camera_shm_dtos.keys()}- aggregation_output_queue = Queue()-- all_ready_events = {camera_id: multiprocessing.Event() for camera_id in camera_shm_dtos.keys()}- all_ready_events[-1] = multiprocessing.Event()- camera_nodes = {camera_id: MocapCameraNode.create(config=config,- camera_id=CameraId(camera_id),- camera_shm_dto=camera_shm_dtos[- camera_id],- output_queue=camera_output_queues[- camera_id],- all_ready_events=all_ready_events,- shutdown_event=shutdown_event)- for camera_id, config in config.camera_node_configs.items()}- return cls(config=config,- camera_nodes=camera_nodes,- aggregation_node=MocapAggregationProcessNode.create(config=config.aggregation_node_config,- input_queues=camera_output_queues,- output_queue=aggregation_output_queue,- all_ready_events=all_ready_events,- shutdown_event=shutdown_event),- # NOTE - this `annotator` is not the same annotator as the one that will be created in the tracker, but will be able to process its outputs- annotator=MocapPipelineImageAnnotator.create(- configs={camera_id: config.tracker_config.annotator_config for camera_id, config in- config.camera_node_configs.items()}),- all_ready_events=all_ready_events,- shutdown_event=shutdown_event,- )diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/mocap_task/mocap_aggregation_node.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/mocap_task/mocap_aggregation_node.pydeleted file mode 100644index b5507237..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/mocap_task/mocap_aggregation_node.py+++ /dev/null@@ -1,120 +0,0 @@-import logging-import multiprocessing-import time-from dataclasses import dataclass-from multiprocessing import Queue, Process-from typing import Dict--from freemocap.core.pipeline.realtime_pipeline.realtime_aggregation_node import RealtimeAggregationNode-from freemocap.core.pipeline.processing_pipeline import BaseAggregationLayerOutputData, BasePipelineStageConfig, \- BasePipelineOutputData-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.mocap_task.mocap_camera_node import MocapCameraNodeOutputData-from freemocap.core.pipeline.realtime_pipeline.realtime_tasks.mocap_task.old_point_trangulator import PointTriangulator--logger = logging.getLogger(__name__)---@dataclass-class MocapAggregationLayerOutputData(BaseAggregationLayerOutputData):- pass---@dataclass-class MocapAggregationNodeConfig(BasePipelineStageConfig):- param2: int = 2---class MocapPipelineOutputData(BasePipelineOutputData):- camera_node_output: dict[CameraId, MocapCameraNodeOutputData]- aggregation_layer_output: MocapAggregationLayerOutputData---class MocapAggregationProcessNode(RealtimeAggregationNode):- @classmethod- def create(cls,- config: MocapAggregationNodeConfig,- input_queues: dict[CameraId, Queue],- output_queue: Queue,- all_ready_events: dict[CameraId | str, multiprocessing.Event],- shutdown_event: multiprocessing.Event):- return cls(config=config,- process=Process(target=cls._run,- kwargs=dict(config=config,- input_queues=input_queues,- output_queue=output_queue,- all_ready_events=all_ready_events,- shutdown_event=shutdown_event)- ),- input_queues=input_queues,- output_queue=output_queue,- shutdown_event=shutdown_event)-- @staticmethod- def _run(config: MocapAggregationNodeConfig,- input_queues: Dict[CameraId, Queue],- output_queue: Queue,- all_ready_events: dict[CameraId | str, multiprocessing.Event],- shutdown_event: multiprocessing.Event):- all_ready_events[-1].set()- logger.trace(f"Aggregation processing node ready!")- point_triangulator = PointTriangulator.create()- while not all([value.is_set() for value in all_ready_events.values()]):- time.sleep(0.001)- logger.trace(f"All processing nodes ready!")- try:- camera_node_incoming_data: dict[CameraId, MocapCameraNodeOutputData | None] = {camera_id: None for- camera_id in- input_queues.keys()}-- while not shutdown_event.is_set():-- while any([queue.empty() for queue in input_queues.values()]):- time.sleep(0.001)- continue-- for camera_id in input_queues.keys():- camera_node_output = input_queues[camera_id].get()- if not isinstance(camera_node_output, MocapCameraNodeOutputData):- raise ValueError(- f"Unexpected data type received from camera {camera_id}: {type(camera_node_output)}")- camera_node_incoming_data[camera_id] = camera_node_output-- if any([camera_node_output is None for camera_node_output in camera_node_incoming_data.values()]):- logger.exception(f"Received None from camera nodes! got {camera_node_incoming_data}")- raise ValueError(f"Received None from camera nodes! got {camera_node_incoming_data}")- frame_numbers = set(- [camera_node_output.frame_metadata.frame_number for camera_node_output in- camera_node_incoming_data.values()])- if len(frame_numbers) > 1:- logger.exception(f"Frame numbers from camera nodes do not match! got {frame_numbers}")- raise ValueError(f"Frame numbers from camera nodes do not match! got {frame_numbers}")- latest_frame_number = frame_numbers.pop()-- # TODO: Fix triangulation, until then just return the single camera 3d estimates- # points2d_by_camera = {camera_id: camera_node_output.mediapipe_observation.all_points(dimensions=2) for- # camera_id, camera_node_output in camera_node_incoming_data.items()}- # points3d: dict[str, tuple] = point_triangulator.triangulate(points2d_by_camera=points2d_by_camera,- # scale_by=0.001)-- points3d = {}- for camera_id, camera_node_output in camera_node_incoming_data.items():- if camera_node_output is None:- raise ValueError(f"Camera {camera_id} did not send any data!")-- points3d.update({f"Cam{camera_id}.{name}": tuple(point_xyz) for name, point_xyz in- camera_node_output.mediapipe_observation.all_points(dimensions=3,- scale_by=0.001).items()})-- output = MocapPipelineOutputData(camera_node_output=camera_node_incoming_data, # type: ignore- aggregation_layer_output=MocapAggregationLayerOutputData(- multi_frame_number=latest_frame_number,- points3d=points3d)- )-- output_queue.put(output)- except Exception as e:- logger.exception(f"Error in aggregation processing node", exc_info=e)- raise- finally:- logger.trace(f"Shutting down aggregation processing node")- shutdown_event.set()diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/mocap_task/mocap_camera_node.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/mocap_task/mocap_camera_node.pydeleted file mode 100644index 13ef195f..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/mocap_task/mocap_camera_node.py+++ /dev/null@@ -1,110 +0,0 @@-import logging-import multiprocessing-import time-from dataclasses import dataclass-from multiprocessing import Queue, Process--from skellycam.core.camera_group.camera.config.camera_config import CameraConfig-from skellycam.core.camera_group.shmorchestrator.shared_memory.single_slot_camera_shared_memory import \- CameraSharedMemoryDTO, SingleSlotCameraSharedMemory-from skellycam.core.frames.payloads.metadata.frame_metadata import FrameMetadata-from skellytracker.trackers.mediapipe_tracker import MediapipeTrackerConfig, MediapipeTracker-from skellytracker.trackers.mediapipe_tracker.mediapipe_observation import MediapipeObservation--from freemocap.core.pipeline.processing_pipeline import BaseCameraNode, BasePipelineStageConfig, \- BaseCameraNodeOutputData--logger = logging.getLogger(__name__)---@dataclass-class MocapPipelineCameraNodeConfig(BasePipelineStageConfig):- camera_config: CameraConfig- tracker_config: MediapipeTrackerConfig- param1: int = 1---@dataclass-class MocapCameraNodeOutputData(BaseCameraNodeOutputData):- frame_metadata: FrameMetadata- mediapipe_observation: MediapipeObservation-- def to_serializable_dict(self) -> dict:- return dict(- frame_metadata=self.frame_metadata.model_dump(),- mediapipe_observation=self.mediapipe_observation.to_serializable_dict(),- )---@dataclass-class MocapCameraNode(BaseCameraNode):- @classmethod- def create(cls,- camera_id: CameraId,- config: MocapPipelineCameraNodeConfig,- camera_shm_dto: CameraSharedMemoryDTO,- output_queue: Queue,- all_ready_events: dict[CameraId, multiprocessing.Event],- shutdown_event: multiprocessing.Event,- ):- return cls(camera_id=camera_id,- config=config,- incoming_frame_shm=SingleSlotCameraSharedMemory.recreate(camera_config=config.camera_config,- camera_shm_dto=camera_shm_dto,- read_only=False),- process=Process(target=cls._run,- kwargs=dict(camera_id=camera_id,- config=config,- camera_shm_dto=camera_shm_dto,- output_queue=output_queue,- all_ready_events=all_ready_events,- shutdown_event=shutdown_event- )- ),- all_ready_events=all_ready_events,- shutdown_event=shutdown_event- )-- @staticmethod- def _run(camera_id: CameraId,- config: MocapPipelineCameraNodeConfig,- camera_shm_dto: CameraSharedMemoryDTO,- output_queue: Queue,- all_ready_events: dict[CameraId, multiprocessing.Event],- shutdown_event: multiprocessing.Event,- ):- frame_intake_shm = SingleSlotCameraSharedMemory.recreate(- camera_config=config.camera_config,- camera_shm_dto=camera_shm_dto,- read_only=False)-- mediapipe_tracker = MediapipeTracker.create(config=config.tracker_config)- try:- logger.trace(f"Camera#{camera_id} processing node ready!")- all_ready_events[camera_id].set()- while not shutdown_event.is_set():- time.sleep(0.001)- if not all([event.is_set() for event in all_ready_events.values()]):- continue- if frame_intake_shm.new_frame_available:- tik = time.perf_counter_ns()- frame = frame_intake_shm.retrieve_frame()- time_to_retrieve = time.perf_counter_ns() - tik- tik = time.perf_counter_ns()- observation, raw_results = mediapipe_tracker.process_image(frame.image, annotate_image=False)-- time_to_process = time.perf_counter_ns() - tik- output_queue.put(MocapCameraNodeOutputData(- frame_metadata=FrameMetadata.from_frame_metadata_array(frame.metadata),- mediapipe_observation=observation,- time_to_retrieve_frame_ns=time_to_retrieve,- time_to_process_frame_ns=time_to_process- ),- )- except Exception as e:- logger.exception(f"Error in camera processing node for camera {camera_id}", exc_info=e)- raise- finally:- logger.trace(f"Shutting down camera processing node for camera {camera_id}")- shutdown_event.set()- frame_intake_shm.close()diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/single_frame_triangulator.py b/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/single_frame_triangulator.pydeleted file mode 100644index 2bb9c306..00000000--- a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/single_frame_triangulator.py+++ /dev/null@@ -1,289 +0,0 @@-import logging-from dataclasses import dataclass-from pathlib import Path-from typing import TYPE_CHECKING--import numpy as np-from numpy.typing import NDArray--from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.freemocap_anipose import (- AniposeCameraGroup-)--from skellycam.core.types.type_overloads import CameraIdString-from skellytracker.trackers.base_tracker.base_tracker_abcs import CharucoObservation--logger = logging.getLogger(__name__)---@dataclass-class TriangulatedObservationFrame:- """Result of triangulating observations from multiple cameras."""- frame_number: int- points_3d: NDArray[np.float32] # Shape: (n_points, 3)- reprojection_error: NDArray[np.float32] # Shape: (n_points,)- reprojection_error_by_camera: NDArray[np.float32] # Shape: (n_cameras, n_points)- valid_points: NDArray[np.bool_] # Shape: (n_points,) - mask of successfully triangulated points- nan_mask: NDArray[np.bool_] # Shape: (n_points,) - mask of points with NaN in any camera- observations_by_camera: dict[str, 'CharucoObservation'] # Original observations for reference---@dataclass-class ObservationTriangulator:- camera_group: AniposeCameraGroup- use_ransac: bool = False- min_cameras_for_triangulation: int = 2- max_reprojection_error: float = 10.0- min_cameras_with_detection: int = 2-- @property- def camera_names(self) -> list[str]:- return [cam.name for cam in self.camera_group.cameras]-- @property- def n_cameras(self) -> int:- return len(self.camera_group.cameras)-- @classmethod- def create(- cls,- *,- calibration_toml_path: str|Path,) -> 'ObservationTriangulator':- camera_group = AniposeCameraGroup.load(str(calibration_toml_path))- return cls(camera_group=camera_group)---- def triangulate_observations(- self,- *,- observations_by_camera: dict[CameraIdString, CharucoObservation],- frame_number: int | None = None,- ) -> TriangulatedObservationFrame:- """- Triangulate observations from multiple synchronized cameras.-- Args:- observations_by_camera: Dict mapping camera_id to BaseObservation instance- frame_number: Optional frame number (will use observation's frame_number if not provided)-- Returns:- TriangulatedObservationFrame with 3D points and metrics-- Raises:- ValueError: If insufficient cameras or mismatched observations- """- if len(observations_by_camera) < self.min_cameras_for_triangulation:- raise ValueError(- f"Need at least {self.min_cameras_for_triangulation} cameras, "- f"got {len(observations_by_camera)}"- )-- # Extract frame number from first observation if not provided- if frame_number is None:- frame_number = next(iter(observations_by_camera.values())).frame_number-- # Verify all observations are from same frame- frame_numbers = {obs.frame_number for obs in observations_by_camera.values()}- if len(frame_numbers) > 1:- raise ValueError(- f"Observations from different frames: {frame_numbers}. "- "All observations must be synchronized."- )--- # Order according to calibration- ordered_frames = self._order_observation_frames(observations_by_camera)-- # Stack 2D points and handle NaNs- points_2d, nan_mask = self._stack_observations_with_nan_handling(ordered_frames)-- # Triangulate only points visible in enough cameras- points_3d, reproj_error, reproj_error_by_cam = self._triangulate_with_nan_handling(- points_2d=points_2d,- nan_mask=nan_mask,- )-- # Determine valid points- valid_points = (~nan_mask) & (reproj_error < self.max_reprojection_error)-- return TriangulatedObservationFrame(- frame_number=frame_number,- points_3d=points_3d,- reprojection_error=reproj_error,- reprojection_error_by_camera=reproj_error_by_cam,- valid_points=valid_points,- nan_mask=nan_mask,- observations_by_camera=observations_by_camera,- )-- def _order_observation_frames(- self,- observations_by_camera: dict[CameraIdString, CharucoObservation],- ) -> dict[CameraIdString, CharucoObservation]:- """- Order observation frames to match calibration camera order.-- Args:- observations_by_camera: Unordered observation frames-- Returns:- List of ObservationFrame2D ordered by calibration-- Raises:- ValueError: If camera not found in calibration- """- ordered_observations: dict[CameraIdString, CharucoObservation | None] = {camera_id: None for camera_id in self.camera_names}- found_cameras: set[CameraIdString] = set()-- for cam_name in self.camera_names:- found = False- for camera_id, observation in observations_by_camera.items():- if cam_name in camera_id:- if camera_id in found_cameras:- raise ValueError(f"Duplicate camera data for {camera_id}")- ordered_observations[camera_id] = observation- found_cameras.add(camera_id)- found = True- break-- if not found:- raise ValueError(- f"Camera {cam_name} from calibration not found in observations. "- f"Available cameras: {[camera_id for camera_id in observations_by_camera.keys()]} "- f"Expected cameras: {self.camera_names}"--- )-- if any(obs is None for obs in ordered_observations.values()):- missing_cameras = [cam_id for cam_id, obs in ordered_observations.items() if obs is None]- raise ValueError(f"Missing observations for cameras: {missing_cameras}")-- return ordered_observations-- def _stack_observations_with_nan_handling(- self,- ordered_frames: dict[CameraIdString,CharucoObservation],- ) -> tuple[NDArray[np.float32], NDArray[np.bool_]]:- """- Stack 2D points from observations, handling NaNs for missing detections.-- Args:- ordered_frames: Observation frames ordered by calibration-- Returns:- Tuple of:- - points_2d: Shape (n_cameras, n_points, 2) with NaNs preserved- - nan_mask: Shape (n_points,) True where any camera has NaN-- Raises:- ValueError: If observations have different numbers of points- """- # Get 2D points from each observation- points_arrays = [frame.to_2d_array() for frame in ordered_frames.values()]-- # Verify all have same number of points- n_points = points_arrays[0].shape[0]- for i, points in enumerate(points_arrays[1:], 1):- if points.shape[0] != n_points:- raise ValueError(- f"Camera {ordered_frames[i].camera_id} has {points.shape[0]} points, "- f"expected {n_points} (from {ordered_frames[0].camera_id})"- )-- # Stack into (n_cameras, n_points, 2)- points_2d = np.stack(points_arrays, axis=0)-- # Find points that are NaN in any camera- nan_mask_per_camera = np.any(np.isnan(points_2d), axis=2) # (n_cameras, n_points)-- # Count how many cameras see each point- cameras_per_point = np.sum(~nan_mask_per_camera, axis=0) # (n_points,)-- # Mark points as invalid if not seen by enough cameras- nan_mask = cameras_per_point < self.min_cameras_with_detection-- return points_2d, nan_mask-- def _triangulate_with_nan_handling(- self,- *,- points_2d: NDArray[np.float32],- nan_mask: NDArray[np.bool_],- ) -> tuple[NDArray[np.float32], NDArray[np.float32], NDArray[np.float32]]:- """- Triangulate 2D points, handling NaN values appropriately.-- Args:- points_2d: Shape (n_cameras, n_points, 2) potentially with NaNs- nan_mask: Shape (n_points,) indicating invalid points-- Returns:- Tuple of:- - points_3d: Shape (n_points, 3) with NaNs for invalid points- - reprojection_error: Shape (n_points,) with inf for invalid points- - reprojection_error_by_camera: Shape (n_cameras, n_points)- """- n_cameras, n_points, _ = points_2d.shape-- # Initialize outputs- points_3d = np.full((n_points, 3), np.nan, dtype=np.float32)- reproj_error = np.full(n_points, np.inf, dtype=np.float32)- reproj_error_by_camera = np.full((n_cameras, n_points), np.inf, dtype=np.float32)-- # Get indices of valid points- valid_indices = np.where(~nan_mask)[0]-- if len(valid_indices) == 0:- logger.warning("No valid points to triangulate")- return points_3d, reproj_error, reproj_error_by_camera-- # Extract valid points for triangulation- # For each valid point, we still need all camera views (even with NaNs)- # Anipose should handle NaN values in the input- points_2d_valid = points_2d[:, valid_indices, :]-- # Reshape for Anipose- points_2d_flat = points_2d_valid.reshape(n_cameras, -1, 2)-- # Triangulate- if self.use_ransac:- points_3d_flat = self.camera_group.triangulate_ransac(- points_2d_flat,- progress=False,- kill_event=None,- )- else:- points_3d_flat = self.camera_group.triangulate(- points_2d_flat,- progress=False,- kill_event=None,- )-- if points_3d_flat is None:- raise RuntimeError("Triangulation failed")-- # Calculate reprojection errors for valid points- reproj_error_full = self.camera_group.reprojection_error(- points_3d_flat, points_2d_flat- )-- # Mean reprojection error per valid point- reproj_error_valid = self.camera_group.calculate_mean_reprojection_error(- reproj_error_full- ).reshape(len(valid_indices))-- # Reprojection error by camera for valid points- reproj_error_by_cam_valid = np.linalg.norm(- reproj_error_full, axis=2- ).reshape(n_cameras, len(valid_indices))-- # Place results back at correct indices- points_3d[valid_indices] = points_3d_flat.reshape(len(valid_indices), 3)- reproj_error[valid_indices] = reproj_error_valid- reproj_error_by_camera[:, valid_indices] = reproj_error_by_cam_valid-- return points_3d, reproj_error, reproj_error_by_camera--diff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/anipose_flavored_stuff/__init__.py b/freemocap/core/viz/__init__.pysimilarity index 100%rename from freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/anipose_flavored_stuff/__init__.pyrename to freemocap/core/viz/__init__.pydiff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/__init__.py b/freemocap/core/viz/blender/__init__.pysimilarity index 100%rename from freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/__init__.pyrename to freemocap/core/viz/blender/__init__.pydiff --git a/freemocap/core/blender/blender_trajectory_loader.py b/freemocap/core/viz/blender/blender_trajectory_loader.pysimilarity index 99%rename from freemocap/core/blender/blender_trajectory_loader.pyrename to freemocap/core/viz/blender/blender_trajectory_loader.pyindex 8a3ea73e..bd921a17 100644--- a/freemocap/core/blender/blender_trajectory_loader.py+++ b/freemocap/core/viz/blender/blender_trajectory_loader.py@@ -2,11 +2,12 @@Blender script to load mediapipe body tracking data from CSV"""-import bpy-import csvimport colorsys-from pathlib import Path+import csvfrom dataclasses import dataclass+from pathlib import Path++import bpy@dataclassdiff --git a/freemocap/core/viz/frontend_payload.py b/freemocap/core/viz/frontend_payload.pynew file mode 100644index 00000000..cc6d49da--- /dev/null+++ b/freemocap/core/viz/frontend_payload.py@@ -0,0 +1,67 @@+import logging++from pydantic import BaseModel, ConfigDict+from skellycam.core.types.type_overloads import CameraIdString+from skellyforge.data_models.trajectory_3d import Point3d++from freemocap.core.viz.image_overlay.charuco_overlay_data import CharucoOverlayData+from freemocap.core.viz.image_overlay.mediapipe_overlay_data import MediapipeOverlayData+from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.rigid_body_estimator import RigidBodyPose+from freemocap.core.types.type_overloads import TrackedPointNameString+from freemocap.pubsub.pubsub_topics import AggregationNodeOutputMessage++logger = logging.getLogger(__name__)+++class FrontendPayload(BaseModel):+ """Complete payload for frontend visualization.++ Carries both charuco and mediapipe overlay data separately so both+ can be active simultaneously per camera.+ """+ model_config = ConfigDict(+ arbitrary_types_allowed=True,+ validate_assignment=False+ )++ frame_number: int+ charuco_overlays: dict[CameraIdString, CharucoOverlayData]+ mediapipe_overlays: dict[CameraIdString, MediapipeOverlayData]+ tracked_points3d: dict[TrackedPointNameString, Point3d]+ rigid_body_poses: dict[str, RigidBodyPose]++ @classmethod+ def from_aggregation_output(+ cls,+ aggregation_output: AggregationNodeOutputMessage,+ ) -> "FrontendPayload":+ """Create frontend payload from aggregation node output."""+ return cls(+ frame_number=aggregation_output.frame_number,+ charuco_overlays=aggregation_output.charuco_overlay_data,+ mediapipe_overlays=aggregation_output.mediapipe_overlay_data,+ tracked_points3d=aggregation_output.tracked_points3d,+ rigid_body_poses=aggregation_output.rigid_body_poses,+ )++ def to_websocket_dict(self) -> dict:+ """Convert to dictionary suitable for JSON serialization over websocket."""+ return {+ "frame_number": self.frame_number,+ "charuco_overlays": {+ camera_id: overlay.model_dump()+ for camera_id, overlay in self.charuco_overlays.items()+ },+ "mediapipe_overlays": {+ camera_id: overlay.model_dump()+ for camera_id, overlay in self.mediapipe_overlays.items()+ },+ "tracked_points3d": {+ name: point.model_dump()+ for name, point in self.tracked_points3d.items()+ },+ "rigid_body_poses": {+ bone_key: pose.model_dump()+ for bone_key, pose in self.rigid_body_poses.items()+ },+ }\ No newline at end of filediff --git a/freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/__init__.py b/freemocap/core/viz/image_overlay/__init__.pysimilarity index 100%rename from freemocap/core/pipeline/realtime_pipeline/realtime_tasks/calibration_task/ooooold/calibration_helpers/calibration_display_helpers/__init__.pyrename to freemocap/core/viz/image_overlay/__init__.pydiff --git a/freemocap/core/image_overlay/charuco_overlay_data.py b/freemocap/core/viz/image_overlay/charuco_overlay_data.pysimilarity index 100%rename from freemocap/core/image_overlay/charuco_overlay_data.pyrename to freemocap/core/viz/image_overlay/charuco_overlay_data.pydiff --git a/freemocap/core/image_overlay/mediapipe_overlay_data.py b/freemocap/core/viz/image_overlay/mediapipe_overlay_data.pysimilarity index 74%rename from freemocap/core/image_overlay/mediapipe_overlay_data.pyrename to freemocap/core/viz/image_overlay/mediapipe_overlay_data.pyindex 38fa48ac..eff62f3c 100644--- a/freemocap/core/image_overlay/mediapipe_overlay_data.py+++ b/freemocap/core/viz/image_overlay/mediapipe_overlay_data.py@@ -1,8 +1,9 @@from typing import Literal-from pydantic import BaseModel, Field+import numpy as np+from pydantic import BaseModel, Fieldfrom skellycam.core.types.type_overloads import CameraIdString-from skellytracker.trackers.mediapipe_tracker.mediapipe_observation import MediapipeObservation+from skellytracker.trackers.mediapipe_tracker import MediapipeObservationclass MediapipePointModel(BaseModel):@@ -53,112 +54,110 @@ class MediapipeOverlayData(BaseModel):*,camera_id: CameraIdString,observation: MediapipeObservation,- scale: float =.5,+ scale: float = .5,include_face: bool = True,- face_type: str = "contour", # "contour" or "tesselation"- ):+ face_type: str = "contour",+ ) -> "MediapipeOverlayData":"""- Convert MediapipeObservation to Pydantic message model for websocket transmission.+ Convert MediapipeObservation (or MediapipeCompositeObservation) to+ Pydantic message model for websocket transmission.Args:camera_id: ID of the camera that produced this observation- observation: The MediapipeObservation to serialize- scale: Scale factor for coordinates (default 1.0)+ observation: The observation to serialize+ scale: Scale factor for coordinatesinclude_face: Whether to include face landmarksface_type: Type of face landmarks to include ("contour" or "tesselation")-- Returns:- MediapipeOverlayData ready for JSON serialization"""-- # Get all points with proper scalingall_points = observation.all_points(dimensions=3, face_type=face_type, scale_by=scale)-+ body_visibility = observation.body_visibility+# Build body pointsbody_points: list[MediapipePointModel] = []- if observation.pose_landmarks is not None:- for name in observation.body_landmark_names:+ if observation.has_pose:+ for i, name in enumerate(observation.body_landmark_names):if name in all_points:x, y, z = all_points[name]- # Get visibility from the original landmark- landmark_idx = observation.body_landmark_names.index(name)- visibility = observation.pose_landmarks.landmark[landmark_idx].visibility if observation.pose_landmarks else 0.0-+ if np.isnan(x) or np.isnan(y) or np.isnan(z):+ continuebody_points.append(MediapipePointModel(name=name,x=float(x),y=float(y),z=float(z),- visibility=float(visibility),+ visibility=float(body_visibility[i]),))-+# Build right hand pointsright_hand_points: list[MediapipePointModel] = []- if observation.right_hand_landmarks is not None:+ if observation.has_right_hand:for name in observation.right_hand_landmark_names:if name in all_points:x, y, z = all_points[name]+ if np.isnan(x) or np.isnan(y) or np.isnan(z):+ continueright_hand_points.append(MediapipePointModel(- name=name.replace("right_hand.", ""), # Remove prefix+ name=name.replace("right_hand.", ""),x=float(x),y=float(y),z=float(z),- visibility=1.0, # Hand landmarks don't have visibility in MediaPipe+ visibility=1.0,))-+# Build left hand pointsleft_hand_points: list[MediapipePointModel] = []- if observation.left_hand_landmarks is not None:+ if observation.has_left_hand:for name in observation.left_hand_landmark_names:if name in all_points:x, y, z = all_points[name]+ if np.isnan(x) or np.isnan(y) or np.isnan(z):+ continueleft_hand_points.append(MediapipePointModel(- name=name.replace("left_hand.", ""), # Remove prefix+ name=name.replace("left_hand.", ""),x=float(x),y=float(y),z=float(z),- visibility=1.0, # Hand landmarks don't have visibility in MediaPipe+ visibility=1.0,))-- # Build face points (if requested)++ # Build face pointsface_points: list[MediapipePointModel] = []- if include_face and observation.face_landmarks is not None:+ if include_face and observation.has_face:face_landmark_names = (- observation.face_contour_landmark_names- if face_type == "contour"+ observation.face_contour_landmark_names+ if face_type == "contour"else [f"face_{i:04d}" for i in range(observation.num_face_tesselation_points)])-for name in face_landmark_names:if name in all_points:x, y, z = all_points[name]+ if np.isnan(x) or np.isnan(y) or np.isnan(z):+ continueface_points.append(MediapipePointModel(name=name,x=float(x),y=float(y),z=float(z),- visibility=1.0, # Face landmarks don't have visibility+ visibility=1.0,))-- # Build metadata+metadata = MediapipeMetadataModel(n_body_detected=len(body_points),n_right_hand_detected=len(right_hand_points),n_left_hand_detected=len(left_hand_points),n_face_detected=len(face_points),- image_width=observation.image_size[0],- image_height=observation.image_size[1],+ image_width=observation.image_size[1],+ image_height=observation.image_size[0],)-- # Build complete message+return cls(camera_id=camera_id,frame_number=observation.frame_number,@@ -167,5 +166,4 @@ class MediapipeOverlayData(BaseModel):left_hand_points=left_hand_points,face_points=face_points,metadata=metadata,- )-+ )\ No newline at end of filediff --git a/freemocap/pubsub/pubsub_abcs.py b/freemocap/pubsub/pubsub_abcs.pyindex 1d1d8c32..fda2df40 100644--- a/freemocap/pubsub/pubsub_abcs.py+++ b/freemocap/pubsub/pubsub_abcs.py@@ -1,5 +1,6 @@import logging-from typing import TypeVar, Generic, Callable, ClassVar+from queue import Empty+from typing import TypeVar, Generic, ClassVarfrom pydantic import BaseModel, Field, ConfigDict, create_model@@ -16,14 +17,18 @@ class TopicMessageABC(BaseModel):)-# MessageType represents "any type that is a subclass of TopicMessageABC"-# This allows each topic to be strongly typed with its specific message type-# e.g., PubSubTopicABC[TestMessage] means "a topic that handles TestMessage"MessageType = TypeVar('MessageType', bound=TopicMessageABC)class PubSubTopicABC(BaseModel, Generic[MessageType]):- """Base pub/sub topic with default behavior."""+ """+ Base pub/sub topic. Main-process only.++ Publishers write to the publication queue (via bare queue handles+ in children, or via publish() in the main process). The PubSubRelay+ thread reads from the publication queue and fans out to all+ subscription queues.+ """topic_registry: ClassVar[set[type['PubSubTopicABC']]] = set()message_type: type[TopicMessageABC]@@ -35,24 +40,46 @@ class PubSubTopicABC(BaseModel, Generic[MessageType]):def __init_subclass__(cls, **kwargs) -> None:"""Auto-register when subclassed."""super().__init_subclass__(**kwargs)- if not cls.__name__.startswith('_'): # Skip private/base classes- PubSubTopicABC.topic_registry.add(cls)+ PubSubTopicABC.topic_registry.add(cls)@classmethoddef get_registered_topics(cls) -> set[type['PubSubTopicABC']]:return cls.topic_registry.copy()def get_subscription(self) -> TopicSubscriptionQueue:+ """Create and register a new subscription queue."""sub = TopicSubscriptionQueue()self.subscriptions.append(sub)return subdef publish(self, message: MessageType) -> None:+ """+ Publish a message by writing it to the publication queue.+ The PubSubRelay thread handles distribution to subscribers.+ """if not isinstance(message, self.message_type):- raise TypeError(f"Message must be of type {self.message_type.__name__}, got {type(message).__name__}")+ raise TypeError(+ f"Message must be of type {self.message_type.__name__}, "+ f"got {type(message).__name__}"+ )self.publication.put(message)- for sub in self.subscriptions:- sub.put(message)++ def relay_to_subscribers(self) -> int:+ """+ Drain the publication queue and fan out to all subscribers.+ Called by the PubSubRelay thread while holding the subscriptions lock.+ Returns the number of messages relayed.+ """+ relayed = 0+ while True:+ try:+ message = self.publication.get_nowait()+ except Empty:+ break+ for sub in self.subscriptions:+ sub.put(message)+ relayed += 1+ return relayeddef close(self) -> None:if hasattr(self.publication, 'close'):@@ -64,12 +91,11 @@ class PubSubTopicABC(BaseModel, Generic[MessageType]):# ============================================================================-# Factory Function - Eliminates Boilerplate Using Pydantic's create_model+# Factory Function# ============================================================================def create_topic(message_type: type[MessageType],- publication_factory: Callable[[], TopicPublicationQueue] | None = None,) -> type[PubSubTopicABC[MessageType]]:"""Factory that creates a topic class for a message type.@@ -79,20 +105,10 @@ def create_topic("""topic_name = message_type.__name__.replace('Message', 'Topic')- # Build field definitions for create_model- # Format: field_name=(type, Field(...))field_definitions: dict[str, object] = {'message_type': (type[MessageType], message_type),}- # Add custom publication factory if provided- if publication_factory is not None:- field_definitions['publication'] = (- TopicPublicationQueue,- Field(default_factory=publication_factory)- )-- # Use Pydantic's create_model - the proper v2 way!topic_class = create_model(topic_name,__base__=PubSubTopicABC,@@ -100,4 +116,4 @@ def create_topic(**field_definitions)- return topic_class+ return topic_class\ No newline at end of filediff --git a/freemocap/pubsub/pubsub_manager.py b/freemocap/pubsub/pubsub_manager.pyindex 2393b14e..acc8abeb 100644--- a/freemocap/pubsub/pubsub_manager.py+++ b/freemocap/pubsub/pubsub_manager.py@@ -1,64 +1,91 @@-# ============================================================================-# PubSubTopicManager - Auto-discovers and manages all registered topics-# ============================================================================+"""+PubSubTopicManager: auto-discovers registered topics, owns the relay thread.+Main-process only. Never pickled to children. Owned directly by the pipeline.++Lifecycle:+ - create() instantiates all topics and starts the relay thread+ - close() drains remaining messages, stops the relay, and closes all queues+"""import logging+import multiprocessingfrom multiprocessing import parent_process-from pydantic import BaseModel, Field, ConfigDict+from pydantic import BaseModel, Field, ConfigDict, PrivateAttr-from freemocap.core.types.type_overloads import TopicSubscriptionQueue, PipelineIdString+from freemocap.core.types.type_overloads import TopicPublicationQueue, TopicSubscriptionQueuefrom freemocap.pubsub.pubsub_abcs import PubSubTopicABC, MessageType+from freemocap.pubsub.pubsub_relay import PubSubRelaylogger = logging.getLogger(__name__)class PubSubTopicManager(BaseModel):"""- Manager for pub/sub topics. Auto-instantiates all registered topic classes.+ Manager for pub/sub topics. Auto-instantiates all registered topic classes+ and runs a relay thread for message fan-out.Usage:- manager = PubSubTopicManager.create()- sub = manager.get_subscription(ProcessFrameNumberTopic)- manager.publish(ProcessFrameNumberTopic, message)+ pubsub = PubSubTopicManager.create(global_kill_flag=flag)+ sub = pubsub.get_subscription(SomeTopic)+ pub_queue = pubsub.get_publication_queue(SomeTopic)+ pubsub.publish(SomeTopic, message) # main-process publishing"""- # Dict maps topic classes to their instances: {ProcessFrameNumberTopic: <instance>}topics: dict[type[PubSubTopicABC], PubSubTopicABC] = Field(default_factory=dict)+ _relay: PubSubRelay | None = PrivateAttr(default=None)model_config = ConfigDict(arbitrary_types_allowed=True)@classmethod- def create(cls) -> "PubSubTopicManager":- """Factory method: creates manager and auto-instantiates all registered topics."""+ def create(cls, global_kill_flag: multiprocessing.Value) -> "PubSubTopicManager":+ """+ Factory: creates manager, instantiates all registered topics,+ and starts the relay thread.+ """+ if parent_process() is not None:+ raise RuntimeError("PubSubTopicManager must be created in the main process")+manager = cls()for topic_cls in PubSubTopicABC.get_registered_topics():manager.topics[topic_cls] = topic_cls()logger.debug(f"Instantiated topic: {topic_cls.__name__}")++ manager._relay = PubSubRelay(+ topics=manager.topics,+ global_kill_flag=global_kill_flag,+ )+ manager._relay.start()+ logger.debug(+ f"PubSubTopicManager created with {len(manager.topics)} topics "+ f"and relay thread started"+ )return managerdef get_subscription(self, topic_type: type[PubSubTopicABC]) -> TopicSubscriptionQueue:- """- Get a subscription queue for a topic.-- Args:- topic_type: The topic CLASS (e.g., ProcessFrameNumberTopic)- """+ """Get a subscription queue for a topic. Thread-safe."""if parent_process() is not None:- raise RuntimeError("Subscriptions must be created in the main process and passed to children")-- if topic_type not in self.topics:- raise ValueError(- f"Unknown topic type: {topic_type.__name__}. "- f"Available topics: {[t.__name__ for t in self.topics.keys()]}"+ raise RuntimeError(+ "Subscriptions must be created in the main process "+ "and passed to children")+ if self._relay is None:+ raise RuntimeError("PubSubTopicManager has no relay — was it created via create()?")- sub = self.topics[topic_type].get_subscription()- logger.trace(- f"Subscribed to topic {topic_type.__name__} "- f"with {len(self.topics[topic_type].subscriptions)} subscriptions"- )- return sub+ self._relay.check_alive()+ return self._relay.create_subscription(topic_type=topic_type)++ def get_publication_queue(self, topic_type: type[PubSubTopicABC]) -> TopicPublicationQueue:+ """+ Get the publication queue for a topic.+ Returns a bare multiprocessing.Queue — pickle-safe, pass directly+ to child processes as a kwarg.+ """+ if self._relay is None:+ raise RuntimeError("PubSubTopicManager has no relay — was it created via create()?")++ self._relay.check_alive()+ return self._relay.get_publication_queue(topic_type=topic_type)def publish(self,@@ -66,47 +93,26 @@ class PubSubTopicManager(BaseModel):message: MessageType) -> None:"""- Publish a message to a topic.-- Args:- topic_type: The topic CLASS to publish to- message: The message to publish+ Publish a message from the main process.+ For child-process publishing, use get_publication_queue() instead."""if topic_type not in self.topics:raise ValueError(f"Unknown topic type: {topic_type.__name__}. "f"Available topics: {[t.__name__ for t in self.topics.keys()]}")-self.topics[topic_type].publish(message)def close(self) -> None:- """Close all topics in the manager."""+ """Stop the relay thread (draining remaining messages), then close all topics."""logger.debug("Closing PubSubTopicManager...")++ if self._relay is not None:+ self._relay.stop()+ self._relay = None+for topic in self.topics.values():topic.close()self.topics.clear()- logger.debug("PubSubTopicManager closed.")---# ============================================================================-# Global pipeline manager registry-# ============================================================================--PIPELINE_PUB_SUB_MANAGERS: dict[PipelineIdString, PubSubTopicManager] = {}---def create_pipeline_pubsub_manager(pipeline_id: PipelineIdString) -> PubSubTopicManager:- """Create/replace manager for a pipeline. Must be called from main process."""- global PIPELINE_PUB_SUB_MANAGERS-- if parent_process() is not None:- raise RuntimeError("PubSubManager can only be created in the main process.")-- if PIPELINE_PUB_SUB_MANAGERS.get(pipeline_id) is not None:- logger.debug(f"Closing existing PubSubManager for pipeline {pipeline_id}")- PIPELINE_PUB_SUB_MANAGERS[pipeline_id].close()- logger.debug(f"Creating PubSubManager for pipeline {pipeline_id}")- PIPELINE_PUB_SUB_MANAGERS[pipeline_id] = PubSubTopicManager.create()- return PIPELINE_PUB_SUB_MANAGERS[pipeline_id]+ logger.debug("PubSubTopicManager closed.")\ No newline at end of filediff --git a/freemocap/pubsub/pubsub_relay.py b/freemocap/pubsub/pubsub_relay.pynew file mode 100644index 00000000..552f7c81--- /dev/null+++ b/freemocap/pubsub/pubsub_relay.py@@ -0,0 +1,191 @@+"""+PubSubRelay: a dedicated thread that reads from topic publication queues+and fans out messages to all subscribers.++This decouples publishers from subscribers:+ - Publishers (in any process) only write to the publication queue+ - The relay (in the main process) handles distribution+ - Subscriptions can be added at any time without ordering constraints++The relay owns the subscriptions lock, coordinating between the main thread+(adding subscriptions) and the relay thread (iterating subscriptions).++If the relay thread dies from an unhandled exception, it sets the global_kill_flag+to bring down all processes.+"""+import logging+import multiprocessing+import threading+import time+from dataclasses import dataclass, field++from freemocap.core.types.type_overloads import TopicPublicationQueue, TopicSubscriptionQueue+from freemocap.pubsub.pubsub_abcs import PubSubTopicABC++logger = logging.getLogger(__name__)++RELAY_POLL_INTERVAL_SECONDS: float = 0.001 # 1ms idle sleep when no messages+RELAY_SHUTDOWN_TIMEOUT_SECONDS: float = 5.0+RELAY_DRAIN_TIMEOUT_SECONDS: float = 2.0+++@dataclass+class PubSubRelay:+ """+ Fan-out relay thread for the pubsub system.++ Polls all topic publication queues in a tight loop. When a message+ is found, it is distributed to every subscription queue for that topic.+ On shutdown, remaining messages are drained before the thread exits.++ Owns the subscriptions lock — both create_subscription() and the relay+ loop acquire it, so subscriptions can be safely added while the relay+ is running.++ If the relay thread crashes, global_kill_flag is set immediately to+ bring down all processes.+ """+ topics: dict[type[PubSubTopicABC], PubSubTopicABC]+ global_kill_flag: multiprocessing.Value+ _subscriptions_lock: threading.Lock = field(default_factory=threading.Lock)+ _stop_event: threading.Event = field(default_factory=threading.Event)+ _thread: threading.Thread | None = field(default=None, init=False)+ _fatal_error: BaseException | None = field(default=None, init=False)++ def create_subscription(self, topic_type: type[PubSubTopicABC]) -> TopicSubscriptionQueue:+ """+ Create a new subscription queue for a topic. Thread-safe.+ Called from the main thread; coordinates with the relay thread+ via the subscriptions lock.+ """+ if topic_type not in self.topics:+ raise ValueError(+ f"Unknown topic type: {topic_type.__name__}. "+ f"Available topics: {[t.__name__ for t in self.topics.keys()]}"+ )+ with self._subscriptions_lock:+ return self.topics[topic_type].get_subscription()++ def get_publication_queue(self, topic_type: type[PubSubTopicABC]) -> TopicPublicationQueue:+ """+ Get the publication queue for a topic.+ Returns a bare multiprocessing.Queue — pickle-safe, pass directly+ to child processes as a kwarg.+ """+ if topic_type not in self.topics:+ raise ValueError(+ f"Unknown topic type: {topic_type.__name__}. "+ f"Available topics: {[t.__name__ for t in self.topics.keys()]}"+ )+ return self.topics[topic_type].publication++ def start(self) -> None:+ """Start the relay thread. Raises if already running."""+ if self._thread is not None and self._thread.is_alive():+ raise RuntimeError("PubSubRelay is already running")++ self._stop_event.clear()+ self._thread = threading.Thread(+ target=self._relay_loop,+ name="PubSubRelay",+ daemon=False,+ )+ self._thread.start()+ logger.debug("PubSubRelay thread started")++ def _relay_loop(self) -> None:+ """Main relay loop. Polls all publication queues and fans out messages."""+ logger.debug("PubSubRelay loop entering")+ try:+ while not self._stop_event.is_set():+ relayed_any = self._relay_one_pass()+ if not relayed_any:+ time.sleep(RELAY_POLL_INTERVAL_SECONDS)+ except Exception as e:+ self._fatal_error = e+ logger.exception("Fatal error in PubSubRelay thread — setting global kill flag")+ self.global_kill_flag.value = True+ raise+ finally:+ logger.debug("PubSubRelay loop exiting")++ def _relay_one_pass(self) -> bool:+ """+ Do one pass over all topics, relaying any pending messages.+ Holds the subscriptions lock while iterating to coordinate+ with create_subscription().+ Returns True if any messages were relayed.+ """+ relayed_any = False+ with self._subscriptions_lock:+ for topic in self.topics.values():+ count = topic.relay_to_subscribers()+ if count > 0:+ relayed_any = True+ return relayed_any++ def _drain(self) -> None:+ """+ Drain all remaining messages from publication queues to subscribers.+ Called during shutdown to ensure no messages are lost.+ """+ deadline = time.monotonic() + RELAY_DRAIN_TIMEOUT_SECONDS+ total_drained = 0++ while time.monotonic() < deadline:+ drained_this_pass = 0+ with self._subscriptions_lock:+ for topic in self.topics.values():+ drained_this_pass += topic.relay_to_subscribers()+ total_drained += drained_this_pass+ if drained_this_pass == 0:+ break+ time.sleep(RELAY_POLL_INTERVAL_SECONDS)++ if total_drained > 0:+ logger.debug(f"PubSubRelay drained {total_drained} messages during shutdown")++ def check_alive(self) -> None:+ """+ Raise if the relay thread has died unexpectedly.+ Call this before operations that depend on the relay.+ """+ if self._fatal_error is not None:+ raise RuntimeError(+ "PubSubRelay thread died with a fatal error"+ ) from self._fatal_error+ if self._thread is not None and not self._thread.is_alive() and not self._stop_event.is_set():+ raise RuntimeError(+ "PubSubRelay thread died unexpectedly without a captured error"+ )++ def stop(self) -> None:+ """+ Stop the relay thread. Drains remaining messages before exiting.+ Raises RuntimeError if the thread does not stop within the timeout,+ or re-raises any fatal error that killed the relay.+ """+ if self._thread is None or not self._thread.is_alive():+ if self._fatal_error is not None:+ raise RuntimeError(+ "PubSubRelay thread had already died with a fatal error"+ ) from self._fatal_error+ logger.debug("PubSubRelay stop called but thread is not running")+ return++ logger.debug("PubSubRelay stopping — signaling thread to exit")+ self._stop_event.set()+ self._thread.join(timeout=RELAY_SHUTDOWN_TIMEOUT_SECONDS)++ if self._thread.is_alive():+ raise RuntimeError(+ f"PubSubRelay thread did not stop within "+ f"{RELAY_SHUTDOWN_TIMEOUT_SECONDS}s timeout"+ )++ self._drain()+ logger.debug("PubSubRelay stopped")++ @property+ def is_alive(self) -> bool:+ return self._thread is not None and self._thread.is_alive()\ No newline at end of filediff --git a/freemocap/pubsub/pubsub_topics.py b/freemocap/pubsub/pubsub_topics.pyindex 5c845c5d..10975669 100644--- a/freemocap/pubsub/pubsub_topics.py+++ b/freemocap/pubsub/pubsub_topics.py@@ -1,40 +1,77 @@+"""+PubSub topic definitions for the pipeline system.++Each Message + Topic pair defines a typed channel. Topics auto-register+via __init_subclass__ so the PubSubTopicManager discovers them at startup.+"""import logging+from typing import TYPE_CHECKINGfrom pydantic import Field, model_validatorfrom skellycam.core.types.type_overloads import CameraGroupIdString, CameraIdString-from skellytracker.trackers.mediapipe_tracker.mediapipe_observation import MediapipeObservation-from skellytracker.trackers.charuco_tracker.charuco_observation import CharucoObservation+from skellyforge.data_models.trajectory_3d import Point3dfrom skellytracker.trackers.base_tracker.base_tracker_abcs import BaseObservation-from freemocap.core.image_overlay.charuco_overlay_data import CharucoOverlayData-from freemocap.core.image_overlay.mediapipe_overlay_data import MediapipeOverlayDatafrom freemocap.core.pipeline.pipeline_configs import RealtimePipelineConfig-from freemocap.core.types.type_overloads import FrameNumberInt, PipelineIdString, VideoIdString, \- TrackedPointNameString+from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.rigid_body_estimator import RigidBodyPose+from freemocap.core.types.type_overloads import (+ FrameNumberInt,+ PipelineIdString,+ VideoIdString,+ TrackedPointNameString,+)from freemocap.pubsub.pubsub_abcs import TopicMessageABC, create_topic-from skellyforge.data_models.trajectory_3d import Point3d+if TYPE_CHECKING:+ from skellytracker.trackers.charuco_tracker.charuco_observation import CharucoObservation+ from skellytracker.trackers.mediapipe_tracker import MediapipeObservation+ from freemocap.core.viz.image_overlay.charuco_overlay_data import CharucoOverlayData+ from freemocap.core.viz.image_overlay.mediapipe_overlay_data import MediapipeOverlayData+logger = logging.getLogger(__name__)+# ---------------------------------------------------------------------------+# Frame processing+# ---------------------------------------------------------------------------+class ProcessFrameNumberMessage(TopicMessageABC):frame_number: int = Field(ge=0, description="Frame number to process")+# ---------------------------------------------------------------------------+# Config updates+# ---------------------------------------------------------------------------+class PipelineConfigUpdateMessage(TopicMessageABC):pipeline_config: RealtimePipelineConfig+# ---------------------------------------------------------------------------+# Realtime node outputs+# ---------------------------------------------------------------------------+class CameraNodeOutputMessage(TopicMessageABC):camera_id: CameraIdStringframe_number: FrameNumberInt = Field(ge=0)- observation: BaseObservation+ charuco_observation: BaseObservation | None+ mediapipe_observation: BaseObservation | None+++# ---------------------------------------------------------------------------+# Video (posthoc) node outputs+# ---------------------------------------------------------------------------class VideoNodeOutputMessage(TopicMessageABC):video_id: VideoIdStringframe_number: FrameNumberInt = Field(ge=0)observation: BaseObservation++# ---------------------------------------------------------------------------+# Aggregation output (realtime)+# ---------------------------------------------------------------------------+class AggregationNodeOutputMessage(TopicMessageABC):frame_number: FrameNumberInt = Field(ge=0)pipeline_id: PipelineIdString@@ -42,41 +79,51 @@ class AggregationNodeOutputMessage(TopicMessageABC):pipeline_config: RealtimePipelineConfigcamera_node_outputs: dict[CameraIdString, CameraNodeOutputMessage]tracked_points3d: dict[TrackedPointNameString, Point3d] = Field(default_factory=dict)+ rigid_body_poses: dict[str, RigidBodyPose] = Field(default_factory=dict)@model_validator(mode='after')def validate(self) -> 'AggregationNodeOutputMessage':- # ensure that camera_node_outputs keys match camera IDs in pipeline_configexpected_camera_ids = set(self.pipeline_config.camera_configs.keys())actual_camera_ids = set(self.camera_node_outputs.keys())if sorted(expected_camera_ids) != sorted(actual_camera_ids):raise ValueError(- f"Camera IDs in camera_node_outputs {actual_camera_ids} do not match expected camera IDs from pipeline_config {expected_camera_ids}")- # make sure camera_node_outputs all have the same frame_number as this message+ f"Camera IDs in camera_node_outputs {actual_camera_ids} "+ f"do not match expected camera IDs from pipeline_config {expected_camera_ids}"+ )for cam_output in self.camera_node_outputs.values():if cam_output.frame_number != self.frame_number:- logger.warning(- f"CameraNodeOutputMessage for camera {cam_output.camera_id} has frame number {cam_output.frame_number} which does not match AggregationNodeOutputMessage frame number {self.frame_number}")+ raise ValueError(+ f"CameraNodeOutputMessage for camera {cam_output.camera_id} "+ f"has frame number {cam_output.frame_number} which does not match "+ f"AggregationNodeOutputMessage frame number {self.frame_number}"+ )return self@property- def charuco_overlay_data(self) -> dict[CameraIdString, CharucoOverlayData]:+ def charuco_overlay_data(self) -> dict:+ from skellytracker.trackers.charuco_tracker.charuco_observation import CharucoObservation+ from freemocap.core.viz.image_overlay.charuco_overlay_data import CharucoOverlayData+overlay_data: dict[CameraIdString, CharucoOverlayData] = {}for camera_id, cam_output in self.camera_node_outputs.items():- if cam_output.observation is not None and isinstance(cam_output.observation, CharucoObservation):+ if cam_output.charuco_observation is not None and isinstance(cam_output.charuco_observation, CharucoObservation):overlay_data[camera_id] = CharucoOverlayData.from_charuco_observation(camera_id=camera_id,- observation=cam_output.observation,+ observation=cam_output.charuco_observation,)return overlay_data@property- def mediapipe_overlay_data(self) -> dict[CameraIdString, MediapipeOverlayData]:+ def mediapipe_overlay_data(self) -> dict:+ from skellytracker.trackers.mediapipe_tracker import MediapipeObservation+ from freemocap.core.viz.image_overlay.mediapipe_overlay_data import MediapipeOverlayData+overlay_data: dict[CameraIdString, MediapipeOverlayData] = {}for camera_id, cam_output in self.camera_node_outputs.items():- if cam_output.observation is not None and isinstance(cam_output.observation, MediapipeObservation):+ if cam_output.mediapipe_observation is not None and isinstance(cam_output.mediapipe_observation, MediapipeObservation):overlay_data[camera_id] = MediapipeOverlayData.from_mediapipe_observation(camera_id=camera_id,- observation=cam_output.observation,+ observation=cam_output.mediapipe_observation,)return overlay_data@@ -85,20 +132,25 @@ class AggregationNodeOutputMessage(TopicMessageABC):return list(self.camera_node_outputs.keys())-class StartRealtimeCalibrationTrackingMessage(TopicMessageABC):- """Message to signal that realtime calibration tracking should start."""- pass+# ---------------------------------------------------------------------------+# Posthoc progress reporting+# ---------------------------------------------------------------------------+class PosthocProgressMessage(TopicMessageABC):+ """Progress report from a posthoc pipeline."""+ pipeline_id: PipelineIdString+ phase: str # "collecting_frames", "processing", "complete", "failed"+ progress_fraction: float = Field(ge=0.0, le=1.0)+ detail: str = ""-class ShouldCalibrateMessage(TopicMessageABC):- """Dummy message to signal that calibration should be performed."""- pass+# ---------------------------------------------------------------------------+# Topic instantiation+# ---------------------------------------------------------------------------ProcessFrameNumberTopic = create_topic(ProcessFrameNumberMessage)-ShouldCalibrateTopic = create_topic(ShouldCalibrateMessage)PipelineConfigUpdateTopic = create_topic(PipelineConfigUpdateMessage)CameraNodeOutputTopic = create_topic(CameraNodeOutputMessage)VideoNodeOutputTopic = create_topic(VideoNodeOutputMessage)AggregationNodeOutputTopic = create_topic(AggregationNodeOutputMessage)-StartRealtimeCalibrationTrackingTopic = create_topic(StartRealtimeCalibrationTrackingMessage)+PosthocProgressTopic = create_topic(PosthocProgressMessage)\ No newline at end of filediff --git a/freemocap/system/logging_configuration/filters/stringify_traceback.py b/freemocap/system/logging_configuration/filters/stringify_traceback.pynew file mode 100644index 00000000..2f7f8723--- /dev/null+++ b/freemocap/system/logging_configuration/filters/stringify_traceback.py@@ -0,0 +1,19 @@+import logging+import traceback+++class StringifyTracebackFilter(logging.Filter):+ """Converts live traceback objects in exc_info to pre-formatted strings.++ Some formatters (e.g. ColorFormatter) copy the LogRecord, which fails on+ live traceback objects since they can't be deepcopied or pickled. This+ filter runs before any handler sees the record: it formats the traceback+ into exc_text, then clears exc_info so nothing downstream chokes.+ """++ def filter(self, record: logging.LogRecord) -> bool:+ if record.exc_info and record.exc_info[2] is not None:+ if not record.exc_text:+ record.exc_text = "".join(traceback.format_exception(*record.exc_info))+ record.exc_info = None+ return Truediff --git a/freemocap/system/logging_configuration/formatters/color_formatter.py b/freemocap/system/logging_configuration/formatters/color_formatter.pyindex fba38bb8..8f72fb55 100644--- a/freemocap/system/logging_configuration/formatters/color_formatter.py+++ b/freemocap/system/logging_configuration/formatters/color_formatter.py@@ -1,3 +1,4 @@+import copyimport loggingfrom .custom_formatter import CustomFormatter@@ -20,7 +21,13 @@ class ColorFormatter(CustomFormatter):"""Adds ANSI colors to PID, TID, and log messages"""def format(self, record: logging.LogRecord) -> str:- # Apply PID/TID colors+ # Pre-format exception text so the traceback object doesn't need to survive the copy+ if record.exc_info and not record.exc_text:+ record.exc_text = self.formatException(record.exc_info)++ # Shallow copy to avoid mutating the original record (traceback objects can't be deepcopied)+ record = copy.copy(record)+ record.exc_info = Nonerecord.pid_color = get_hashed_color(record.process)record.tid_color = get_hashed_color(record.thread)@@ -33,4 +40,4 @@ class ColorFormatter(CustomFormatter):formatted = super().format(record)formatted = f"{level_color}{formatted}\033[0m"# Add color to structural elements- return formatted.replace(LOG_POINTER_STRING, f"{level_color}{LOG_POINTER_STRING}\033[0m")+ return formatted.replace(LOG_POINTER_STRING, f"{level_color}{LOG_POINTER_STRING}\033[0m")\ No newline at end of filediff --git a/freemocap/system/logging_configuration/handlers/websocket_log_queue_handler.py b/freemocap/system/logging_configuration/handlers/websocket_log_queue_handler.pyindex 28e3b921..e811cb1d 100644--- a/freemocap/system/logging_configuration/handlers/websocket_log_queue_handler.py+++ b/freemocap/system/logging_configuration/handlers/websocket_log_queue_handler.py@@ -1,11 +1,13 @@import loggingimport multiprocessing-from logging.handlers import QueueHandler+import queue as queue_module+import traceback as traceback_modulefrom multiprocessing import Queuefrom typing import Optional-from skellycam.system.logging_configuration.log_levels import LogLevels+from pydantic import BaseModel+from ..log_levels import LogLevelsfrom ..filters.delta_time import DeltaTimeFilterfrom ..formatters.custom_formatter import CustomFormatterfrom ..log_format_string import LOG_FORMAT_STRING@@ -13,8 +15,48 @@ from ..log_format_string import LOG_FORMAT_STRINGMIN_LOG_LEVEL_FOR_WEBSOCKET = LogLevels.TRACE.value-class WebSocketQueueHandler(QueueHandler):- """Formats logs and puts them in a queue for websocket distribution"""+class LogRecordModel(BaseModel):+ name: str+ msg: str+ args: list+ levelname: str+ levelno: int+ pathname: str+ filename: str+ module: str+ lineno: int+ funcName: str+ created: float+ msecs: float+ relativeCreated: float+ thread: int+ threadName: str+ processName: str+ process: int+ delta_t: str+ message: str+ asctime: str+ formatted_message: str+ type: str+ message_type: str = "log_record"+ exc_info: str | None = None+ exc_text: str | None = None+ stack_info: str | None = None+++class WebSocketQueueHandler(logging.Handler):+ """Formats logs and puts them in a queue for websocket distribution.++ Uses non-blocking put: if the queue is full, the log message is+ silently dropped. Blocking the calling thread (which may be a camera+ frame-grab loop) to wait for the websocket relay to drain is never+ acceptable.++ Builds the queue payload from explicit field extraction rather than+ splatting record.__dict__, which avoids pickling failures from+ unpicklable args (cv2.VideoCapture, CameraConfig, etc.), unknown+ fields (taskName on 3.12+), and traceback frame locals.+ """def __init__(self, queue: multiprocessing.Queue):super().__init__()@@ -22,15 +64,64 @@ class WebSocketQueueHandler(QueueHandler):self.addFilter(DeltaTimeFilter())self.setFormatter(CustomFormatter(LOG_FORMAT_STRING))- def emit(self, record: logging.LogRecord):- if record.levelno > MIN_LOG_LEVEL_FOR_WEBSOCKET:- try:- # Prepare the record for pickling (handles exception info)- prepared_record = self.prepare(record)- print(f"---------------------\n--------------------\n------------WebSocketQueueHandler emitting record: {prepared_record.getMessage()}\n--------------------------\n--------------------\n------------")- self.queue.put(prepared_record)- except Exception:- self.handleError(record)+ def emit(self, record: logging.LogRecord) -> None:+ if record.levelno < MIN_LOG_LEVEL_FOR_WEBSOCKET:+ return+ try:+ # Format first — populates record.message and record.asctime+ formatted_message = self.format(record)++ # Convert exc_info to string safely+ exc_info_str: str | None = None+ if record.exc_info:+ try:+ exc_info_str = "".join(+ traceback_module.format_exception(*record.exc_info)+ )+ except Exception:+ exc_info_str = f"{record.exc_info[0].__name__}: {record.exc_info[1]}"++ exc_text_str: str | None = None+ if record.exc_text:+ exc_text_str = str(record.exc_text)++ stack_info_str: str | None = None+ if record.stack_info:+ stack_info_str = str(record.stack_info)++ payload = LogRecordModel(+ name=record.name,+ msg=str(record.msg) if record.msg is not None else "",+ args=[], # Args are already baked into record.message — no need to pickle them+ levelname=record.levelname,+ levelno=record.levelno,+ pathname=record.pathname,+ filename=record.filename,+ module=record.module,+ lineno=record.lineno,+ funcName=record.funcName,+ created=record.created,+ msecs=record.msecs,+ relativeCreated=record.relativeCreated,+ thread=record.thread or 0,+ threadName=record.threadName or "",+ processName=record.processName or "",+ process=record.process or 0,+ delta_t=getattr(record, "delta_t", "0.000ms"),+ message=record.getMessage(),+ asctime=getattr(record, "asctime", ""),+ formatted_message=formatted_message,+ type="LogRecord",+ exc_info=exc_info_str,+ exc_text=exc_text_str,+ stack_info=stack_info_str,+ ).model_dump()++ self.queue.put_nowait(payload)+ except queue_module.Full:+ pass+ except Exception:+ self.handleError(record)MAX_WEBSOCKET_LOG_QUEUE_SIZE = 1000@@ -48,4 +139,4 @@ def get_websocket_log_queue() -> Queue:global WEBSOCKET_LOG_QUEUEif WEBSOCKET_LOG_QUEUE is None:raise ValueError("Websocket log queue not created yet")- return WEBSOCKET_LOG_QUEUE+ return WEBSOCKET_LOG_QUEUE\ No newline at end of filediff --git a/freemocap/system/logging_configuration/logger_builder.py b/freemocap/system/logging_configuration/logger_builder.pyindex 6fb3c1f5..1593e3f8 100644--- a/freemocap/system/logging_configuration/logger_builder.py+++ b/freemocap/system/logging_configuration/logger_builder.py@@ -4,6 +4,7 @@ from multiprocessing import Queuefrom typing import Optionalfrom .filters.delta_time import DeltaTimeFilter+from .filters.stringify_traceback import StringifyTracebackFilterfrom .handlers.colored_console import ColoredConsoleHandlerfrom .handlers.websocket_log_queue_handler import WebSocketQueueHandlerfrom .log_format_string import LOG_FORMAT_STRING@@ -20,15 +21,18 @@ class LoggerBuilder:self.queue = queuedictConfig({"version": 1, "disable_existing_loggers": False})- def _configure_root_logger(self):+ def _configure_root_logger(self) -> None:root = logging.getLogger()root.setLevel(self.level.value)+ # Stringify live traceback objects before any handler sees the record,+ # to avoid pickling errors when sending to the frontend+ root.addFilter(StringifyTracebackFilter())# Clear existing handlersfor handler in root.handlers[:]:root.removeHandler(handler)- # Add new handlers+ # Add handlersroot.addHandler(self._build_file_handler())if self.queue:@@ -36,24 +40,28 @@ class LoggerBuilder:root.addHandler(self._build_console_handler())- def _build_console_handler(self):+ def _build_console_handler(self) -> logging.Handler:handler = ColoredConsoleHandler()handler.setLevel(self.level.value)return handler- def _build_file_handler(self):+ def _build_file_handler(self) -> logging.Handler:handler = logging.FileHandler(get_log_file_path(), encoding="utf-8")handler.setFormatter(logging.Formatter(LOG_FORMAT_STRING))- handler.addFilter(DeltaTimeFilter()) # Add this line+ handler.addFilter(DeltaTimeFilter())handler.setLevel(LogLevels.TRACE.value)return handler- def _build_websocket_handler(self):- print("\n\n\n\nBuilding WebSocket log handler\n\n\n\n")+ def _build_websocket_handler(self) -> logging.Handler:handler = WebSocketQueueHandler(self.queue)handler.setLevel(self.level.value)return handler- def configure(self):- if len(logging.getLogger().handlers) == 0:- self._configure_root_logger()+ def configure(self) -> None:+ """Configure the root logger, clearing any pre-existing handlers.++ Always runs — if something else added handlers before us (a library+ calling basicConfig, etc.) we replace them with our full handler set+ so the WebSocketQueueHandler is guaranteed to be attached.+ """+ self._configure_root_logger()\ No newline at end of filediff --git a/freemocap/tests/conftest.py b/freemocap/tests/conftest.pyindex 85da60c6..8ecbba2f 100644--- a/freemocap/tests/conftest.py+++ b/freemocap/tests/conftest.py@@ -1,70 +1,161 @@-# import pytest-#-# from freemocap.old.core_processes.process_motion_capture_videos.process_recording_headless import (-# process_recording_headless,-# find_calibration_toml_path,-# )-# from freemocap.old.data_layer.recording_models.recording_info_model import RecordingInfoModel-# from freemocap.utilities.download_sample_data import (-# download_sample_data,-# )-#-#-# class SessionInfo:-# sample_session_folder_path: str-# recording_info_model: RecordingInfoModel-#-# def pytest_sessionstart():-# SessionInfo.sample_session_folder_path = download_sample_data()-# calibration_toml_path = find_calibration_toml_path(SessionInfo.sample_session_folder_path)-# SessionInfo.recording_info_model = RecordingInfoModel(-# recording_folder_path=SessionInfo.sample_session_folder_path, active_tracker="mediapipe"-# )-# # TODO: make this configurable to be able to take different trackers-# process_recording_headless(-# recording_path=SessionInfo.sample_session_folder_path,-# path_to_camera_calibration_toml=calibration_toml_path,-# recording_info_model=SessionInfo.recording_info_model,-# run_blender=False,-# make_jupyter_notebook=False,-# use_tqdm=False,-# )-#-#-# @pytest.fixture-# def sample_session_path():-# return SessionInfo.sample_session_folder_path-#-#-# @pytest.fixture-# def synchronized_video_folder_path():-# return SessionInfo.recording_info_model.synchronized_videos_folder_path-#-#-# @pytest.fixture-# def data_folder_path():-# return SessionInfo.recording_info_model.output_data_folder_path-#-#-# @pytest.fixture-# def raw_skeleton_data():-# return SessionInfo.recording_info_model.raw_data_3d_npy_file_path-#-#-# @pytest.fixture-# def total_body_center_of_mass_data():-# return SessionInfo.recording_info_model.total_body_center_of_mass_npy_file_path-#-#-# @pytest.fixture-# def image_tracking_data():-# return SessionInfo.recording_info_model.data_2d_npy_file_path-#-#-# @pytest.fixture-# def reprojection_error_data():-# return SessionInfo.recording_info_model.reprojection_error_data_npy_file_path-#-#-# if __name__ == "__main__":-# pytest_sessionstart()+"""+Shared fixtures for end-to-end integration tests.++Builds a FastAPI app with the real routers mounted at the correct prefixes,+backed by a mock FreemocapApplication that has a real SettingsManager and+mock pipeline/camera managers. This lets us test the full HTTP→SettingsManager+→WebSocket round-trip without requiring camera hardware.+"""+import asyncio+import threading+from copy import deepcopy+from dataclasses import dataclass, field+from unittest.mock import MagicMock, patch++import pytest+from fastapi import APIRouter, FastAPI, WebSocket+from fastapi.testclient import TestClient+from starlette.websockets import WebSocketState++from freemocap.api.http.calibration.calibration_router import calibration_router+from freemocap.api.http.mocap.mocap_router import mocap_router+from freemocap.app.settings import SettingsManager+from freemocap.app.settings_protocol import (+ handle_settings_message,+ settings_state_relay,+)+from freemocap.core.pipeline.pipeline_configs import (+ CalibrationPipelineConfig,+ MocapPipelineConfig,+)+++# ---------------------------------------------------------------------------+# Mock application components+# ---------------------------------------------------------------------------+++class MockPipeline:+ """Records update_config calls without touching real hardware."""++ def __init__(self) -> None:+ self.config = MagicMock()+ self.config.calibration_config = CalibrationPipelineConfig()+ self.config.mocap_config = MocapPipelineConfig.default_realtime()+ self.update_config_calls: list[object] = []++ def update_config(self, new_config: object) -> None:+ self.update_config_calls.append(deepcopy(new_config))+++class MockPipelineManager:+ def __init__(self) -> None:+ self.lock = threading.Lock()+ self.pipeline = MockPipeline()+ self.pipelines: dict[str, MockPipeline] = {"test-pipeline": self.pipeline}+++@dataclass+class MockFreemocapApp:+ """Minimal mock that provides a real SettingsManager with mock hardware."""++ settings_manager: SettingsManager = field(default_factory=SettingsManager)+ realtime_pipeline_manager: MockPipelineManager = field(default_factory=MockPipelineManager)+++# ---------------------------------------------------------------------------+# Simplified WebSocket endpoint for testing settings relay+# ---------------------------------------------------------------------------+++def _create_settings_ws_router(mock_app: MockFreemocapApp) -> APIRouter:+ """+ Create a WebSocket router that runs only the settings relay and+ message handler — no image relay, no log relay, no camera hardware.+ """+ router = APIRouter()++ @router.websocket("/websocket/connect")+ async def settings_ws(websocket: WebSocket) -> None:+ await websocket.accept()+ stop = False++ async def relay() -> None:+ await settings_state_relay(+ websocket=websocket,+ settings_manager=mock_app.settings_manager,+ should_continue=lambda: not stop,+ )++ relay_task = asyncio.create_task(relay())++ try:+ while not stop:+ message = await websocket.receive()+ msg_type = message.get("type", "")++ if msg_type == "websocket.disconnect":+ stop = True+ break++ if "text" in message:+ import json++ data = json.loads(message["text"])+ data_message_type = data.get("message_type", "")+ if data_message_type.startswith("settings/"):+ handle_settings_message(+ data=data,+ settings_manager=mock_app.settings_manager,+ app=mock_app,+ )+ except Exception:+ stop = True+ finally:+ stop = True+ mock_app.settings_manager.notify_changed()+ relay_task.cancel()+ try:+ await relay_task+ except asyncio.CancelledError:+ pass++ return router+++# ---------------------------------------------------------------------------+# Fixtures+# ---------------------------------------------------------------------------+++def mock_app() -> MockFreemocapApp:+ return MockFreemocapApp()+++def e2e_app(mock_app: MockFreemocapApp) -> FastAPI:+ """+ Build a FastAPI app matching the real route structure:+ - /freemocap/calibration/...+ - /freemocap/mocap/...+ - /websocket/connect (settings-only, no hardware)+ """+ app = FastAPI()+ app.include_router(calibration_router, prefix="/freemocap")+ app.include_router(mocap_router, prefix="/freemocap")+ app.include_router(_create_settings_ws_router(mock_app))+ return app+++def e2e_client(e2e_app: FastAPI, mock_app: MockFreemocapApp) -> TestClient:+ """TestClient wired to the full E2E app with mocked get_freemocap_app."""+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ), patch(+ "freemocap.api.http.mocap.mocap_router.get_freemocap_app",+ return_value=mock_app,+ ):+ yield TestClient(e2e_app)diff --git a/freemocap/tests/test_by_camera_reprojection_filtering.py b/freemocap/tests/test_by_camera_reprojection_filtering.pydeleted file mode 100644index 8278c1c7..00000000--- a/freemocap/tests/test_by_camera_reprojection_filtering.py+++ /dev/null@@ -1,96 +0,0 @@-import numpy as np--from freemocap.zzold.core_processes import (- _get_camera_frame_marker_lists_to_reproject,- _set_unincluded_data_to_nans,-)---def test_get_camera_frame_marker_lists_to_reproject():- # test removing one camera- reprojError_cam_frame_marker = np.array(- [[[1, 5, 3], [4, 5, 6], [7, 8, 9]], [[2, 3, 4], [5, 6, 9], [8, 9, 10]], [[3, 6, 5], [6, 7, 8], [9, 10, 11]]]- )- frame_marker_list = [(0, 1), (1, 2)]- num_cameras_to_remove = 1- expected_output = ([[2], [1]], [0, 1], [1, 2])- assert (- _get_camera_frame_marker_lists_to_reproject(- reprojError_cam_frame_marker, frame_marker_list, num_cameras_to_remove- )- == expected_output- )- # test removing two cameras- frame_marker_list = [(0, 1), (1, 2)]- num_cameras_to_remove = 2- expected_output = ([[2, 0], [1, 2]], [0, 1], [1, 2])- assert (- _get_camera_frame_marker_lists_to_reproject(- reprojError_cam_frame_marker, frame_marker_list, num_cameras_to_remove- )- == expected_output- )- # test removing all cameras- frame_marker_list = [(0, 1), (1, 2)]- num_cameras_to_remove = 3- expected_output = ([[2, 0, 1], [1, 2, 0]], [0, 1], [1, 2])- assert (- _get_camera_frame_marker_lists_to_reproject(- reprojError_cam_frame_marker, frame_marker_list, num_cameras_to_remove- )- == expected_output- )- # test removing more cameras than dimensions- frame_marker_list = [(0, 1), (1, 2)]- num_cameras_to_remove = 4- # should just return all of the camera sorted by max reprojection error, no need to error- expected_output = ([[2, 0, 1], [1, 2, 0]], [0, 1], [1, 2])- assert (- _get_camera_frame_marker_lists_to_reproject(- reprojError_cam_frame_marker, frame_marker_list, num_cameras_to_remove- )- == expected_output- )- # test providing no frames or markers- frame_marker_list = []- num_cameras_to_remove = 2- expected_output = ([], [], [])- assert (- _get_camera_frame_marker_lists_to_reproject(- reprojError_cam_frame_marker, frame_marker_list, num_cameras_to_remove- )- == expected_output- )---def test_set_unincluded_data_to_nans():- # test indices are turned to nans- data = np.random.rand(5, 5, 5, 2)- frames_with_reprojection_error = [1, 2]- markers_with_reprojection_error = [3, 4]- cameras_to_remove = [[0, 1], [2, 3]]- result = _set_unincluded_data_to_nans(data, frames_with_reprojection_error, markers_with_reprojection_error,- cameras_to_remove)- for cameras, frame, marker in zip(cameras_to_remove, frames_with_reprojection_error,- markers_with_reprojection_error):- for camera in cameras:- np.testing.assert_array_equal(result[camera, frame, marker, :], np.full((2,), np.nan))-- # test other indices aren't touched- data = np.random.rand(5, 5, 5, 2)- frames_with_reprojection_error = [1, 2]- markers_with_reprojection_error = [3, 4]- cameras_to_remove = [[0, 1], [2, 3]]- original_data = data.copy()- result = _set_unincluded_data_to_nans(data, frames_with_reprojection_error, markers_with_reprojection_error,- cameras_to_remove)- mask = np.ones(data.shape, dtype=bool)- for cameras, frame, marker in zip(cameras_to_remove, frames_with_reprojection_error,- markers_with_reprojection_error):- for camera in cameras:- mask[camera, frame, marker, :] = False- np.testing.assert_array_equal(result[mask], original_data[mask])---if __name__ == "__main__":- test_get_camera_frame_marker_lists_to_reproject()diff --git a/freemocap/tests/test_e2e_http_settings_sync.py b/freemocap/tests/test_e2e_http_settings_sync.pynew file mode 100644index 00000000..3722e1b8--- /dev/null+++ b/freemocap/tests/test_e2e_http_settings_sync.py@@ -0,0 +1,405 @@+"""+End-to-end HTTP integration tests.++Tests the full request path from frontend URL → FastAPI router (with real+prefixes) → SettingsManager → pipeline sync. Unlike the unit tests in+test_http_config_endpoints.py which test individual routers in isolation,+these tests mount routers at the same prefixes the real app uses+(/freemocap/calibration/..., /freemocap/mocap/...) and verify the full+flow through a single app instance.++What these catch that unit tests don't:+ - Route prefix mounting issues (e.g. double-prefix bugs)+ - Cross-router interactions through a shared SettingsManager+ - Settings version monotonicity across multiple endpoint calls+ - Full serialization round-trip with real Pydantic validation+"""+from unittest.mock import patch++import pytest+from fastapi.testclient import TestClient++from freemocap.core.pipeline.pipeline_configs import MocapPipelineConfig+from freemocap.tests.conftest import MockFreemocapApp+++# ---------------------------------------------------------------------------+# Calibration config update: full route path+# ---------------------------------------------------------------------------+++class TestCalibrationConfigFullRoute:+ """Verify /freemocap/calibration/config/update/all works end-to-end."""++ def test_config_update_at_real_prefix(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ """The frontend hits /freemocap/calibration/config/update/all."""+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ response = e2e_client.post(+ "/freemocap/calibration/config/update/all",+ json={+ "config": {+ "charucoBoardXSquares": 9,+ "charucoBoardYSquares": 7,+ "charucoSquareLength": 25.0,+ "solverMethod": "pyceres",+ "useGroundplane": True,+ },+ },+ )+ assert response.status_code == 200+ assert response.json()["success"] is True++ def test_config_update_propagates_to_settings_manager(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ e2e_client.post(+ "/freemocap/calibration/config/update/all",+ json={+ "config": {+ "charucoBoardXSquares": 11,+ "charucoBoardYSquares": 9,+ "charucoSquareLength": 30.0,+ "solverMethod": "anipose",+ "useGroundplane": False,+ },+ },+ )+ cal = mock_app.settings_manager.settings.calibration.config+ assert cal.charuco_board_x_squares == 11+ assert cal.charuco_board_y_squares == 9+ assert cal.charuco_square_length == 30.0++ def test_config_update_syncs_to_pipeline(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ e2e_client.post(+ "/freemocap/calibration/config/update/all",+ json={+ "config": {+ "charucoBoardXSquares": 7,+ "charucoBoardYSquares": 5,+ "charucoSquareLength": 39.0,+ "solverMethod": "anipose",+ "useGroundplane": False,+ },+ },+ )+ pipeline = mock_app.realtime_pipeline_manager.pipeline+ assert len(pipeline.update_config_calls) == 1+ synced = pipeline.update_config_calls[0]+ assert synced.calibration_config.charuco_board_x_squares == 7++ def test_invalid_config_returns_422(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ response = e2e_client.post(+ "/freemocap/calibration/config/update/all",+ json={+ "config": {+ "charucoBoardXSquares": -1,+ "charucoBoardYSquares": 5,+ "charucoSquareLength": 39.0,+ "solverMethod": "anipose",+ "useGroundplane": False,+ },+ },+ )+ assert response.status_code == 422+++# ---------------------------------------------------------------------------+# Mocap config update: full route path+# ---------------------------------------------------------------------------+++class TestMocapConfigFullRoute:+ """Verify /freemocap/mocap/config/update/all works end-to-end."""++ def test_config_update_at_real_prefix(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ config = MocapPipelineConfig.default_realtime().model_dump()+ with patch(+ "freemocap.api.http.mocap.mocap_router.get_freemocap_app",+ return_value=mock_app,+ ):+ response = e2e_client.post(+ "/freemocap/mocap/config/update/all",+ json={"config": config},+ )+ assert response.status_code == 200+ assert response.json()["success"] is True++ def test_config_update_propagates_to_settings_manager(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ config = MocapPipelineConfig.default_realtime().model_dump()+ config["skeleton_filter"]["beta"] = 0.99+ with patch(+ "freemocap.api.http.mocap.mocap_router.get_freemocap_app",+ return_value=mock_app,+ ):+ e2e_client.post(+ "/freemocap/mocap/config/update/all",+ json={"config": config},+ )+ assert mock_app.settings_manager.settings.mocap.config.skeleton_filter.beta == 0.99+++# ---------------------------------------------------------------------------+# Cross-router interactions through shared SettingsManager+# ---------------------------------------------------------------------------+++class TestCrossRouterSettingsSync:+ """+ Verify that config updates through different routers go through the+ same SettingsManager and produce monotonically increasing versions.+ """++ def test_version_increases_across_calibration_and_mocap_updates(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ assert mock_app.settings_manager.version == 0++ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ), patch(+ "freemocap.api.http.mocap.mocap_router.get_freemocap_app",+ return_value=mock_app,+ ):+ # First: calibration update+ e2e_client.post(+ "/freemocap/calibration/config/update/all",+ json={+ "config": {+ "charucoBoardXSquares": 7,+ "charucoBoardYSquares": 5,+ "charucoSquareLength": 39.0,+ "solverMethod": "anipose",+ "useGroundplane": False,+ },+ },+ )+ version_after_cal = mock_app.settings_manager.version++ # Second: mocap update+ config = MocapPipelineConfig.default_realtime().model_dump()+ e2e_client.post(+ "/freemocap/mocap/config/update/all",+ json={"config": config},+ )+ version_after_mocap = mock_app.settings_manager.version++ assert version_after_cal >= 1+ assert version_after_mocap > version_after_cal++ def test_calibration_update_does_not_clobber_mocap(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ """Updating calibration config must not touch mocap config."""+ original_mocap = mock_app.settings_manager.settings.mocap.model_dump()++ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ e2e_client.post(+ "/freemocap/calibration/config/update/all",+ json={+ "config": {+ "charucoBoardXSquares": 11,+ "charucoBoardYSquares": 9,+ "charucoSquareLength": 50.0,+ "solverMethod": "pyceres",+ "useGroundplane": True,+ },+ },+ )++ assert mock_app.settings_manager.settings.mocap.model_dump() == original_mocap++ def test_mocap_update_does_not_clobber_calibration(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ """Updating mocap config must not touch calibration config."""+ # First set calibration to non-default values+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ e2e_client.post(+ "/freemocap/calibration/config/update/all",+ json={+ "config": {+ "charucoBoardXSquares": 11,+ "charucoBoardYSquares": 9,+ "charucoSquareLength": 50.0,+ "solverMethod": "pyceres",+ "useGroundplane": True,+ },+ },+ )++ cal_after_first = mock_app.settings_manager.settings.calibration.model_dump()++ # Now update mocap+ config = MocapPipelineConfig.default_realtime().model_dump()+ config["skeleton_filter"]["beta"] = 0.5+ with patch(+ "freemocap.api.http.mocap.mocap_router.get_freemocap_app",+ return_value=mock_app,+ ):+ e2e_client.post(+ "/freemocap/mocap/config/update/all",+ json={"config": config},+ )++ assert mock_app.settings_manager.settings.calibration.model_dump() == cal_after_first+++# ---------------------------------------------------------------------------+# Frontend payload format: exact JSON shapes from thunks+# ---------------------------------------------------------------------------+++class TestFrontendURLPaths:+ """+ Verify the exact URLs the frontend ServerUrls class constructs+ actually resolve to valid endpoints.+ """++ def test_calibration_start_recording_url_resolves(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ """+ Frontend uses: `${baseUrl}/freemocap/calibration/recording/start`+ Should not 404. May 500 (no cameras) but must not 404 or 422.+ """+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ mock_app.start_recording_all = lambda **kwargs: None+ response = e2e_client.post(+ "/freemocap/calibration/recording/start",+ json={+ "calibrationRecordingDirectory": "/tmp/test_cal",+ "calibrationTaskConfig": {+ "charucoBoardXSquares": 5,+ "charucoBoardYSquares": 3,+ "charucoSquareLength": 1,+ "solverMethod": "anipose",+ "useGroundplane": False,+ },+ },+ )+ assert response.status_code != 404+ assert response.status_code != 422++ def test_mocap_start_recording_url_resolves(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ """+ Frontend uses: `${baseUrl}/freemocap/mocap/recording/start`+ """+ config = MocapPipelineConfig.default_realtime().model_dump()+ with patch(+ "freemocap.api.http.mocap.mocap_router.get_freemocap_app",+ return_value=mock_app,+ ):+ mock_app.start_recording_all = lambda **kwargs: None+ response = e2e_client.post(+ "/freemocap/mocap/recording/start",+ json={+ "mocapRecordingDirectory": "/tmp/test_mocap",+ "mocapTaskConfig": config,+ },+ )+ assert response.status_code != 404+ assert response.status_code != 422++ def test_calibration_config_update_url_resolves(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ """+ Frontend uses: `${baseUrl}/freemocap/calibration/config/update/all`+ """+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ response = e2e_client.post(+ "/freemocap/calibration/config/update/all",+ json={+ "config": {+ "charucoBoardXSquares": 5,+ "charucoBoardYSquares": 3,+ "charucoSquareLength": 1,+ "solverMethod": "anipose",+ "useGroundplane": False,+ },+ },+ )+ assert response.status_code == 200++ def test_mocap_config_update_url_resolves(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ """+ Frontend uses: `${baseUrl}/freemocap/mocap/config/update/all`+ """+ config = MocapPipelineConfig.default_realtime().model_dump()+ with patch(+ "freemocap.api.http.mocap.mocap_router.get_freemocap_app",+ return_value=mock_app,+ ):+ response = e2e_client.post(+ "/freemocap/mocap/config/update/all",+ json={"config": config},+ )+ assert response.status_code == 200diff --git a/freemocap/tests/test_e2e_websocket_settings_sync.py b/freemocap/tests/test_e2e_websocket_settings_sync.pynew file mode 100644index 00000000..1065efd8--- /dev/null+++ b/freemocap/tests/test_e2e_websocket_settings_sync.py@@ -0,0 +1,370 @@+"""+End-to-end WebSocket integration tests.++Tests the full round-trip: client connects via WebSocket → receives initial+settings/state → sends settings/patch → receives updated settings/state with+bumped version. Also tests settings/request and malformed message handling.++What these catch that unit tests don't:+ - WebSocket JSON serialization/deserialization through real Starlette transport+ - Settings relay actually waking up and pushing after a patch+ - Version monotonicity across multiple patches in a single connection+ - The full message_type routing in the WebSocket handler+"""+from unittest.mock import patch++import pytest+from fastapi.testclient import TestClient++from freemocap.tests.conftest import MockFreemocapApp+++# ---------------------------------------------------------------------------+# WebSocket connection + initial state+# ---------------------------------------------------------------------------+++class TestWebSocketInitialState:+ """Verify the WebSocket pushes initial settings/state on connect."""++ def test_receives_initial_settings_state_on_connect(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ with e2e_client.websocket_connect("/websocket/connect") as ws:+ msg = ws.receive_json()+ assert msg["message_type"] == "settings/state"+ assert isinstance(msg["settings"], dict)+ assert isinstance(msg["version"], int)++ def test_initial_state_has_all_top_level_keys(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ with e2e_client.websocket_connect("/websocket/connect") as ws:+ msg = ws.receive_json()+ settings = msg["settings"]+ assert "cameras" in settings+ assert "pipeline" in settings+ assert "calibration" in settings+ assert "mocap" in settings+ assert "vmc" in settings++ def test_initial_version_is_zero(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ with e2e_client.websocket_connect("/websocket/connect") as ws:+ msg = ws.receive_json()+ assert msg["version"] == 0+++# ---------------------------------------------------------------------------+# WebSocket settings/patch → settings/state round-trip+# ---------------------------------------------------------------------------+++class TestWebSocketPatchRoundTrip:+ """Send settings/patch via WebSocket, verify settings/state comes back."""++ def test_patch_calibration_is_recording(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ with e2e_client.websocket_connect("/websocket/connect") as ws:+ initial = ws.receive_json()+ assert initial["settings"]["calibration"]["is_recording"] is False++ ws.send_json({+ "message_type": "settings/patch",+ "patch": {"calibration": {"is_recording": True}},+ })++ updated = ws.receive_json()+ assert updated["message_type"] == "settings/state"+ assert updated["version"] > initial["version"]+ assert updated["settings"]["calibration"]["is_recording"] is True++ def test_patch_calibration_config(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ with e2e_client.websocket_connect("/websocket/connect") as ws:+ initial = ws.receive_json()++ ws.send_json({+ "message_type": "settings/patch",+ "patch": {+ "calibration": {+ "config": {"charuco_board_x_squares": 11},+ },+ },+ })++ updated = ws.receive_json()+ cal_config = updated["settings"]["calibration"]["config"]+ assert cal_config["charuco_board_x_squares"] == 11+ # Sibling fields preserved+ assert cal_config["charuco_board_y_squares"] == 3++ def test_patch_mocap_filter_beta(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ with e2e_client.websocket_connect("/websocket/connect") as ws:+ ws.receive_json() # initial++ ws.send_json({+ "message_type": "settings/patch",+ "patch": {+ "mocap": {+ "config": {+ "skeleton_filter": {"beta": 0.99},+ },+ },+ },+ })++ updated = ws.receive_json()+ skeleton_filter = updated["settings"]["mocap"]["config"]["skeleton_filter"]+ assert skeleton_filter["beta"] == 0.99+ # Sibling fields preserved+ assert skeleton_filter["min_cutoff"] == 0.005++ def test_patch_preserves_unrelated_sections(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ """Patching calibration must not affect mocap."""+ with e2e_client.websocket_connect("/websocket/connect") as ws:+ initial = ws.receive_json()+ original_mocap = initial["settings"]["mocap"]++ ws.send_json({+ "message_type": "settings/patch",+ "patch": {"calibration": {"is_recording": True}},+ })++ updated = ws.receive_json()+ assert updated["settings"]["mocap"] == original_mocap+++# ---------------------------------------------------------------------------+# WebSocket settings/patch syncs to pipelines+# ---------------------------------------------------------------------------+++class TestWebSocketPatchPipelineSync:+ """Verify that config patches via WebSocket sync to running pipelines."""++ def test_calibration_config_patch_syncs_to_pipeline(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ with e2e_client.websocket_connect("/websocket/connect") as ws:+ ws.receive_json() # initial++ ws.send_json({+ "message_type": "settings/patch",+ "patch": {+ "calibration": {+ "config": {"charuco_board_x_squares": 13},+ },+ },+ })++ ws.receive_json() # updated state++ pipeline = mock_app.realtime_pipeline_manager.pipeline+ assert len(pipeline.update_config_calls) == 1++ def test_mocap_config_patch_syncs_to_pipeline(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ with e2e_client.websocket_connect("/websocket/connect") as ws:+ ws.receive_json() # initial++ ws.send_json({+ "message_type": "settings/patch",+ "patch": {+ "mocap": {+ "config": {+ "skeleton_filter": {"beta": 0.1},+ },+ },+ },+ })++ ws.receive_json() # updated state++ pipeline = mock_app.realtime_pipeline_manager.pipeline+ assert len(pipeline.update_config_calls) == 1++ def test_status_only_patch_does_not_sync_pipeline(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ """Patching only is_recording should NOT touch pipelines."""+ with e2e_client.websocket_connect("/websocket/connect") as ws:+ ws.receive_json()++ ws.send_json({+ "message_type": "settings/patch",+ "patch": {"calibration": {"is_recording": True}},+ })++ ws.receive_json()++ pipeline = mock_app.realtime_pipeline_manager.pipeline+ assert len(pipeline.update_config_calls) == 0+++# ---------------------------------------------------------------------------+# Version monotonicity across multiple patches+# ---------------------------------------------------------------------------+++class TestWebSocketVersionMonotonicity:+ """Verify versions always increase across multiple patches."""++ def test_multiple_patches_produce_increasing_versions(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ with e2e_client.websocket_connect("/websocket/connect") as ws:+ initial = ws.receive_json()+ versions = [initial["version"]]++ for i in range(5):+ ws.send_json({+ "message_type": "settings/patch",+ "patch": {+ "calibration": {"recording_progress": float(i * 10)},+ },+ })+ msg = ws.receive_json()+ versions.append(msg["version"])++ for i in range(1, len(versions)):+ assert versions[i] > versions[i - 1], (+ f"Version did not increase: {versions}"+ )+++# ---------------------------------------------------------------------------+# WebSocket settings/request+# ---------------------------------------------------------------------------+++class TestWebSocketSettingsRequest:+ """Verify settings/request triggers a full state push."""++ def test_request_triggers_state_push(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ with e2e_client.websocket_connect("/websocket/connect") as ws:+ initial = ws.receive_json()++ ws.send_json({"message_type": "settings/request"})++ response = ws.receive_json()+ assert response["message_type"] == "settings/state"+ # Version should have bumped (request triggers notify_changed)+ assert response["version"] > initial["version"]+++# ---------------------------------------------------------------------------+# HTTP config update triggers WebSocket state push+# ---------------------------------------------------------------------------+++class TestHTTPToWebSocketRoundTrip:+ """+ The highest-value E2E test: an HTTP POST to a config endpoint triggers+ a settings/state push on the WebSocket with the correct updated values.++ This is exactly what happens in the real app: the frontend sends an HTTP+ POST via a thunk, and the SettingsManager.apply_patch() call inside the+ router notifies the WebSocket relay, which pushes the updated state back.+ """++ def test_http_calibration_update_pushes_websocket_state(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ with e2e_client.websocket_connect("/websocket/connect") as ws:+ initial = ws.receive_json()+ assert initial["version"] == 0++ # HTTP POST from frontend thunk+ response = e2e_client.post(+ "/freemocap/calibration/config/update/all",+ json={+ "config": {+ "charucoBoardXSquares": 9,+ "charucoBoardYSquares": 7,+ "charucoSquareLength": 25.0,+ "solverMethod": "pyceres",+ "useGroundplane": True,+ },+ },+ )+ assert response.status_code == 200++ # WebSocket should receive updated state+ updated = ws.receive_json()+ assert updated["message_type"] == "settings/state"+ assert updated["version"] > 0++ cal = updated["settings"]["calibration"]["config"]+ assert cal["charuco_board_x_squares"] == 9+ assert cal["charuco_board_y_squares"] == 7+ assert cal["charuco_square_length"] == 25.0+ assert cal["solver_method"] == "pyceres"+ assert cal["use_groundplane"] is True++ def test_http_mocap_update_pushes_websocket_state(+ self,+ e2e_client: TestClient,+ mock_app: MockFreemocapApp,+ ) -> None:+ from freemocap.core.pipeline.pipeline_configs import MocapPipelineConfig++ config = MocapPipelineConfig.default_realtime().model_dump()+ config["skeleton_filter"]["beta"] = 0.42++ with patch(+ "freemocap.api.http.mocap.mocap_router.get_freemocap_app",+ return_value=mock_app,+ ):+ with e2e_client.websocket_connect("/websocket/connect") as ws:+ ws.receive_json() # initial++ response = e2e_client.post(+ "/freemocap/mocap/config/update/all",+ json={"config": config},+ )+ assert response.status_code == 200++ updated = ws.receive_json()+ skeleton_filter = updated["settings"]["mocap"]["config"]["skeleton_filter"]+ assert skeleton_filter["beta"] == 0.42diff --git a/freemocap/tests/test_geometry_utilities.py b/freemocap/tests/test_geometry_utilities.pydeleted file mode 100644index 159ef3b5..00000000--- a/freemocap/tests/test_geometry_utilities.py+++ /dev/null@@ -1,79 +0,0 @@-import numpy as np-import pytest--from freemocap.utilities.geometry.project_3d_data_to_z_plane import project_3d_data_to_z_plane-from freemocap.utilities.geometry.rotate_by_90_degrees_around_x_axis import rotate_by_90_degrees_around_x_axis---def test_rotate_by_90_degrees_around_x_axis():- # test single point- raw_skel3d_frame_marker_xyz = np.array([[[1, 2, 3]]])- expected_result = np.array([[[1, 3, -2]]])- assert np.allclose(- rotate_by_90_degrees_around_x_axis(raw_skel3d_frame_marker_xyz), expected_result- ), "Did not correctly rotate the single input point."-- # test multiple points- raw_skel3d_frame_marker_xyz = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]])- expected_result = np.array([[[1, 3, -2], [4, 6, -5], [7, 9, -8]]])- assert np.allclose(- rotate_by_90_degrees_around_x_axis(raw_skel3d_frame_marker_xyz), expected_result- ), "Did not correctly rotate the multiple input points."-- # test empty input- raw_skel3d_frame_marker_xyz = np.array([])- with pytest.raises(ValueError) as exc_info:- rotate_by_90_degrees_around_x_axis(raw_skel3d_frame_marker_xyz)- assert (- str(exc_info.value) == "raw_skel3d_frame_marker_xyz must have shape (N, M, 3)"- ), "Did not correctly handle an empty input array."-- # test zero input- raw_skel3d_frame_marker_xyz = np.array([[[0, 0, 0], [0, 0, 0], [0, 0, 0]]])- expected_result = np.array([[[0, 0, 0], [0, 0, 0], [0, 0, 0]]])- assert np.allclose(- rotate_by_90_degrees_around_x_axis(raw_skel3d_frame_marker_xyz), expected_result- ), "Did not correctly handle a zero input array."---def test_project_3d_data_to_z_plane():- # test simple case- input_data = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])- expected_output = np.array([[[1, 2, 0], [4, 5, 0]], [[7, 8, 0], [10, 11, 0]]])- assert np.array_equal(- project_3d_data_to_z_plane(input_data), expected_output- ), f"Test failed for input_data: {input_data}"-- # test more complex case- input_data = np.array(- [- [[7.80, 5.67, 1.72], [9.71, 9.42, 2.57]],- [[4.85, 4.38, 3.42], [3.26, 1.13, 1.27]],- [[3.70, 1.02, 8.64], [4.85, 5.10, 8.96]],- [[6.57, 2.48, 2.52], [5.08, 1.76, 9.34]],- ]- )- input_data_copy = np.array(- [- [[7.80, 5.67, 1.72], [9.71, 9.42, 2.57]],- [[4.85, 4.38, 3.42], [3.26, 1.13, 1.27]],- [[3.70, 1.02, 8.64], [4.85, 5.10, 8.96]],- [[6.57, 2.48, 2.52], [5.08, 1.76, 9.34]],- ]- )- expected_output = np.array(- [- [[7.80, 5.67, 0], [9.71, 9.42, 0]],- [[4.85, 4.38, 0], [3.26, 1.13, 0]],- [[3.70, 1.02, 0], [4.85, 5.10, 0]],- [[6.57, 2.48, 0], [5.08, 1.76, 0]],- ]- )- assert np.array_equal(- project_3d_data_to_z_plane(input_data), expected_output- ), f"Test failed for input_data: {input_data}"-- # test input data was not changed- assert np.array_equal(- input_data, input_data_copy- ), "Input data was modified by function, function should not change the input data."diff --git a/freemocap/tests/test_http_config_endpoints.py b/freemocap/tests/test_http_config_endpoints.pynew file mode 100644index 00000000..408e62be--- /dev/null+++ b/freemocap/tests/test_http_config_endpoints.py@@ -0,0 +1,445 @@+"""+HTTP endpoint integration tests: verify that the calibration, mocap, and+pipeline routers accept the payloads the frontend sends and correctly+update the SettingsManager.++Uses FastAPI TestClient with a mocked FreemocapApplication.+"""+import threading+from copy import deepcopy+from dataclasses import dataclass, field+from typing import Any+from unittest.mock import MagicMock, patch++import pytest+from fastapi import FastAPI+from fastapi.testclient import TestClient++from freemocap.api.http.calibration.calibration_router import calibration_router+from freemocap.api.http.mocap.mocap_router import mocap_router+from freemocap.app.settings import SettingsManager+from freemocap.core.pipeline.pipeline_configs import (+ CalibrationPipelineConfig,+ MocapPipelineConfig,+)+++# ---------------------------------------------------------------------------+# Mock pipeline for testing config sync+# ---------------------------------------------------------------------------+++class MockPipeline:+ """Minimal mock of a RealtimePipeline that records update_config calls."""++ def __init__(self) -> None:+ self.config = MagicMock()+ self.config.calibration_config = CalibrationPipelineConfig()+ self.config.mocap_config = MocapPipelineConfig.default_realtime()+ self.update_config_calls: list[Any] = []++ def update_config(self, new_config: Any) -> None:+ self.update_config_calls.append(deepcopy(new_config))+++class MockPipelineManager:+ """Minimal mock of RealtimePipelineManager."""++ def __init__(self) -> None:+ self.lock = threading.Lock()+ self.pipeline = MockPipeline()+ self.pipelines: dict[str, MockPipeline] = {"test-pipeline": self.pipeline}+++class MockApp:+ """Minimal mock of FreemocapApplication with a real SettingsManager."""++ def __init__(self) -> None:+ self.settings_manager = SettingsManager()+ self.realtime_pipeline_manager = MockPipelineManager()+++# ---------------------------------------------------------------------------+# Fixtures+# ---------------------------------------------------------------------------+++def mock_app() -> MockApp:+ return MockApp()+++def test_client(mock_app: MockApp) -> TestClient:+ """Create a FastAPI TestClient with calibration and mocap routers,+ using a mocked FreemocapApplication."""+ app = FastAPI()+ app.include_router(calibration_router)+ app.include_router(mocap_router)++ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ), patch(+ "freemocap.api.http.mocap.mocap_router.get_freemocap_app",+ return_value=mock_app,+ ):+ yield TestClient(app)+++# ---------------------------------------------------------------------------+# Calibration config update+# ---------------------------------------------------------------------------+++class TestCalibrationConfigUpdateEndpoint:++ def test_returns_success(self, test_client: TestClient, mock_app: MockApp) -> None:+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ response = test_client.post(+ "/calibration/config/update/all",+ json={+ "config": {+ "charucoBoardXSquares": 7,+ "charucoBoardYSquares": 5,+ "charucoSquareLength": 39.0,+ "solverMethod": "anipose",+ "useGroundplane": False,+ },+ },+ )+ assert response.status_code == 200+ body = response.json()+ assert body["success"] is True++ def test_patches_settings_manager(self, test_client: TestClient, mock_app: MockApp) -> None:+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ test_client.post(+ "/calibration/config/update/all",+ json={+ "config": {+ "charucoBoardXSquares": 7,+ "charucoBoardYSquares": 5,+ "charucoSquareLength": 39.0,+ "solverMethod": "anipose",+ "useGroundplane": False,+ },+ },+ )+ settings = mock_app.settings_manager.settings+ assert settings.calibration.config.charuco_board_x_squares == 7+ assert settings.calibration.config.charuco_board_y_squares == 5+ assert settings.calibration.config.charuco_square_length == 39.0++ def test_syncs_to_pipelines(self, test_client: TestClient, mock_app: MockApp) -> None:+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ test_client.post(+ "/calibration/config/update/all",+ json={+ "config": {+ "charucoBoardXSquares": 9,+ "charucoBoardYSquares": 7,+ "charucoSquareLength": 25.0,+ "solverMethod": "pyceres",+ "useGroundplane": True,+ },+ },+ )+ pipeline = mock_app.realtime_pipeline_manager.pipeline+ assert len(pipeline.update_config_calls) == 1+ synced_config = pipeline.update_config_calls[0]+ assert synced_config.calibration_config.charuco_board_x_squares == 9+ assert synced_config.calibration_config.use_groundplane is True++ def test_bumps_settings_version(self, test_client: TestClient, mock_app: MockApp) -> None:+ assert mock_app.settings_manager.version == 0+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ test_client.post(+ "/calibration/config/update/all",+ json={+ "config": {+ "charucoBoardXSquares": 7,+ "charucoBoardYSquares": 5,+ "charucoSquareLength": 39.0,+ "solverMethod": "anipose",+ "useGroundplane": False,+ },+ },+ )+ assert mock_app.settings_manager.version >= 1++ def test_rejects_invalid_config(self, test_client: TestClient, mock_app: MockApp) -> None:+ """charuco_board_x_squares must be > 0."""+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ response = test_client.post(+ "/calibration/config/update/all",+ json={+ "config": {+ "charucoBoardXSquares": -1,+ "charucoBoardYSquares": 5,+ "charucoSquareLength": 39.0,+ "solverMethod": "anipose",+ "useGroundplane": False,+ },+ },+ )+ assert response.status_code == 422++ def test_rejects_missing_config(self, test_client: TestClient, mock_app: MockApp) -> None:+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ response = test_client.post(+ "/calibration/config/update/all",+ json={},+ )+ assert response.status_code == 422+++# ---------------------------------------------------------------------------+# Mocap config update+# ---------------------------------------------------------------------------+++class TestMocapConfigUpdateEndpoint:++ @pytest.fixture+ def default_mocap_config_payload(self) -> dict[str, Any]:+ return {+ "config": MocapPipelineConfig.default_realtime().model_dump(),+ }++ def test_returns_success(+ self,+ test_client: TestClient,+ mock_app: MockApp,+ default_mocap_config_payload: dict[str, Any],+ ) -> None:+ with patch(+ "freemocap.api.http.mocap.mocap_router.get_freemocap_app",+ return_value=mock_app,+ ):+ response = test_client.post(+ "/mocap/config/update/all",+ json=default_mocap_config_payload,+ )+ assert response.status_code == 200+ body = response.json()+ assert body["success"] is True++ def test_patches_settings_manager(+ self,+ test_client: TestClient,+ mock_app: MockApp,+ ) -> None:+ config = MocapPipelineConfig.default_realtime()+ payload = config.model_dump()+ # Modify a value to verify it propagates+ payload["skeleton_filter"]["beta"] = 0.99++ with patch(+ "freemocap.api.http.mocap.mocap_router.get_freemocap_app",+ return_value=mock_app,+ ):+ test_client.post("/mocap/config/update/all", json={"config": payload})++ settings = mock_app.settings_manager.settings+ assert settings.mocap.config.skeleton_filter.beta == 0.99++ def test_syncs_to_pipelines(+ self,+ test_client: TestClient,+ mock_app: MockApp,+ ) -> None:+ config = MocapPipelineConfig.default_realtime()+ payload = config.model_dump()+ payload["skeleton_filter"]["max_rejected_streak"] = 10++ with patch(+ "freemocap.api.http.mocap.mocap_router.get_freemocap_app",+ return_value=mock_app,+ ):+ test_client.post("/mocap/config/update/all", json={"config": payload})++ pipeline = mock_app.realtime_pipeline_manager.pipeline+ assert len(pipeline.update_config_calls) == 1++ def test_bumps_settings_version(+ self,+ test_client: TestClient,+ mock_app: MockApp,+ default_mocap_config_payload: dict[str, Any],+ ) -> None:+ assert mock_app.settings_manager.version == 0+ with patch(+ "freemocap.api.http.mocap.mocap_router.get_freemocap_app",+ return_value=mock_app,+ ):+ test_client.post("/mocap/config/update/all", json=default_mocap_config_payload)+ assert mock_app.settings_manager.version >= 1+++# ---------------------------------------------------------------------------+# Frontend payload format compatibility+# ---------------------------------------------------------------------------+++class TestFrontendPayloadFormat:+ """Verify that the exact JSON shapes the frontend thunks send+ are accepted by the backend endpoints."""++ def test_calibration_thunk_payload_accepted(+ self,+ test_client: TestClient,+ mock_app: MockApp,+ ) -> None:+ """Simulate the exact payload from updateCalibrationConfigOnServer thunk.+ The frontend sends { config: { ...camelCaseFields } }."""+ payload = {+ "config": {+ "charucoBoardXSquares": 5,+ "charucoBoardYSquares": 3,+ "charucoSquareLength": 1,+ "solverMethod": "anipose",+ "useGroundplane": False,+ },+ }+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ response = test_client.post("/calibration/config/update/all", json=payload)+ assert response.status_code == 200++ def test_start_calibration_recording_payload_accepted(+ self,+ test_client: TestClient,+ mock_app: MockApp,+ ) -> None:+ """Simulate the payload from startCalibrationRecording thunk.+ Uses camelCase field aliases."""+ mock_app.start_recording_all = MagicMock()+ payload = {+ "calibrationRecordingDirectory": "/tmp/test_cal_recording",+ "calibrationTaskConfig": {+ "charucoBoardXSquares": 5,+ "charucoBoardYSquares": 3,+ "charucoSquareLength": 1,+ "solverMethod": "anipose",+ "useGroundplane": False,+ },+ }+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ response = test_client.post("/calibration/recording/start", json=payload)+ # May fail at the actual start_recording (no real cameras), but should not be 422+ assert response.status_code != 422, (+ f"Got 422 validation error for frontend payload: {response.json()}"+ )++ def test_stop_calibration_recording_payload_accepted(+ self,+ test_client: TestClient,+ mock_app: MockApp,+ ) -> None:+ """Simulate the payload from stopCalibrationRecording thunk."""+ payload = {+ "calibrationTaskConfig": {+ "charucoBoardXSquares": 5,+ "charucoBoardYSquares": 3,+ "charucoSquareLength": 1,+ "solverMethod": "anipose",+ "useGroundplane": False,+ },+ }+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ response = test_client.post("/calibration/recording/stop", json=payload)+ # May fail at actual stop (no recording), but should not be 422+ assert response.status_code != 422, (+ f"Got 422 validation error for frontend payload: {response.json()}"+ )++ def test_calibrate_recording_payload_accepted(+ self,+ test_client: TestClient,+ mock_app: MockApp,+ ) -> None:+ """Simulate the payload from calibrateRecording thunk."""+ payload = {+ "calibrationRecordingDirectory": "/tmp/test_cal_recording",+ "calibrationTaskConfig": {+ "charucoBoardXSquares": 5,+ "charucoBoardYSquares": 3,+ "charucoSquareLength": 1,+ "solverMethod": "anipose",+ "useGroundplane": False,+ },+ }+ with patch(+ "freemocap.api.http.calibration.calibration_router.get_freemocap_app",+ return_value=mock_app,+ ):+ response = test_client.post("/calibration/recording/calibrate", json=payload)+ assert response.status_code != 422, (+ f"Got 422 validation error for frontend payload: {response.json()}"+ )++ def test_mocap_start_recording_payload_accepted(+ self,+ test_client: TestClient,+ mock_app: MockApp,+ ) -> None:+ """Simulate the payload from startMocapRecording thunk."""+ config = MocapPipelineConfig.default_realtime().model_dump()+ payload = {+ "mocapRecordingDirectory": "/tmp/test_mocap_recording",+ "mocapTaskConfig": config,+ }+ with patch(+ "freemocap.api.http.mocap.mocap_router.get_freemocap_app",+ return_value=mock_app,+ ):+ response = test_client.post("/mocap/recording/start", json=payload)+ assert response.status_code != 422, (+ f"Got 422 validation error for frontend payload: {response.json()}"+ )++ def test_mocap_stop_recording_payload_accepted(+ self,+ test_client: TestClient,+ mock_app: MockApp,+ ) -> None:+ """Simulate the payload from stopMocapRecording thunk."""+ config = MocapPipelineConfig.default_realtime().model_dump()+ payload = {+ "mocapTaskConfig": config,+ }+ with patch(+ "freemocap.api.http.mocap.mocap_router.get_freemocap_app",+ return_value=mock_app,+ ):+ response = test_client.post("/mocap/recording/stop", json=payload)+ assert response.status_code != 422, (+ f"Got 422 validation error for frontend payload: {response.json()}"+ )diff --git a/freemocap/tests/test_image_tracking_data_shape.py b/freemocap/tests/test_image_tracking_data_shape.pydeleted file mode 100644index dd698f87..00000000--- a/freemocap/tests/test_image_tracking_data_shape.py+++ /dev/null@@ -1,61 +0,0 @@-from pathlib import Path-from typing import Union--import numpy as np-import pytest--from freemocap.utilities.get_number_of_frames_of_videos_in_a_folder import (- get_number_of_frames_of_videos_in_a_folder,-)-from freemocap.utilities.get_video_paths import get_video_paths--[email protected]("synchronized_video_folder_path", "image_tracking_data")-def test_image_tracking_data_exists(- synchronized_video_folder_path: Union[str, Path],- image_tracking_data: Union[str, Path],-):- """- test that the `2d detection` process worked correctly by checking that there is an `.npy` file containing the 2d data in the `output_data_folder`- """-- assert Path(image_tracking_data).is_file(), f"{image_tracking_data} is not a file"--[email protected]("synchronized_video_folder_path", "image_tracking_data")-def test_image_tracking_data_shape(- synchronized_video_folder_path: Union[str, Path],- image_tracking_data: Union[str, Path, np.ndarray],-):- """- test that the `2d detection` process worked correctly by checking:-- The dimensions of that `npy` (number of cameras, number of frames, [ need to do - number of tracked points], [pixelX, pixelY] matches the videos in the `synchronized videos` folder-- TODO - check number of tracked points vs 'expected' number of tracked points- """- if isinstance(image_tracking_data, (str, Path)):- image2d_camera_frame_marker_xyz = np.load(image_tracking_data)- else:- image2d_camera_frame_marker_xyz = image_tracking_data-- list_of_video_paths = get_video_paths(Path(synchronized_video_folder_path))- number_of_videos = len(list_of_video_paths)- assert (- image2d_camera_frame_marker_xyz.shape[0] == number_of_videos- ), f"Number of videos in image_tracking_data does not match number of videos in synchronized videos folder"-- frame_counts = list(get_number_of_frames_of_videos_in_a_folder(synchronized_video_folder_path).values())-- assert (- len(set(frame_counts)) == 1- ), f"Videos in {synchronized_video_folder_path} have different frame counts: {frame_counts}"- assert (- image2d_camera_frame_marker_xyz.shape[1] == frame_counts[0]- ), f"Number of frames in image_tracking_data does not match number of frames of videos in {synchronized_video_folder_path}"-- # TODO - check number of tracked points vs 'expected' number of tracked points-- assert (- image2d_camera_frame_marker_xyz.shape[3] == 3- ), f"Data has {image2d_camera_frame_marker_xyz.shape[3]} dimensions, expected 3 dimensions"diff --git a/freemocap/tests/test_pubsub.py b/freemocap/tests/test_pubsub.pydeleted file mode 100644index 89c3efe5..00000000--- a/freemocap/tests/test_pubsub.py+++ /dev/null@@ -1,525 +0,0 @@-from multiprocessing import Queue-from queue import Empty-from typing import Any--import pytest-from pydantic import Field--from freemocap.pubsub.pubsub_abcs import (- TopicMessageABC,- PubSubTopicABC,- create_topic,-)-from freemocap.pubsub.pubsub_manager import (- PubSubTopicManager,- create_pipeline_pubsub_manager,- PIPELINE_PUB_SUB_MANAGERS,-)---# ============================================================================-# Test Fixtures - Message Types-# ============================================================================--class TestMessage(TopicMessageABC):- """Simple test message."""- value: int---class TestMessageWithData(TopicMessageABC):- """Test message with more fields."""- name: str- count: int = Field(ge=0)- data: dict[str, Any] = Field(default_factory=dict)---class AnotherTestMessage(TopicMessageABC):- """Another message type for testing."""- text: str---# ============================================================================-# Test Fixtures - Topics-# ============================================================================-[email protected](autouse=True)-def clear_topic_registry() -> None:- """Clear the topic registry before each test."""- PubSubTopicABC.topic_registry.clear()- PIPELINE_PUB_SUB_MANAGERS.clear()- yield- PubSubTopicABC.topic_registry.clear()- PIPELINE_PUB_SUB_MANAGERS.clear()---def test_topic_class() -> type[PubSubTopicABC[TestMessage]]:- """Create a test topic class."""- return create_topic(message_type=TestMessage)---def test_topic_instance(test_topic_class: type[PubSubTopicABC[TestMessage]]) -> PubSubTopicABC[TestMessage]:- """Create an instance of test topic."""- return test_topic_class()---# ============================================================================-# Tests for TopicMessageABC-# ============================================================================--def test_topic_message_creation() -> None:- """Test basic message creation."""- msg = TestMessage(value=42)- assert msg.value == 42---def test_topic_message_validation() -> None:- """Test message validation."""- # Should work- msg = TestMessageWithData(name="test", count=5)- assert msg.name == "test"- assert msg.count == 5-- # Should fail validation (count must be >= 0)- with pytest.raises(Exception): # Pydantic validation error- TestMessageWithData(name="test", count=-1)---# ============================================================================-# Tests for PubSubTopicABC - Registration-# ============================================================================--def test_topic_auto_registration() -> None:- """Test that topics auto-register on subclassing."""- initial_count = len(PubSubTopicABC.topic_registry)-- # Create a new topic- TestTopic = create_topic(message_type=TestMessage)-- # Should be registered- assert len(PubSubTopicABC.topic_registry) == initial_count + 1- assert TestTopic in PubSubTopicABC.topic_registry---def test_topic_private_classes_not_registered() -> None:- """Test that private topic classes (starting with _) are not registered."""- initial_count = len(PubSubTopicABC.topic_registry)-- class _PrivateTestTopic(PubSubTopicABC[TestMessage]):- message_type: type[TestMessage] = TestMessage-- # Should NOT be registered- assert len(PubSubTopicABC.topic_registry) == initial_count- assert _PrivateTestTopic not in PubSubTopicABC.topic_registry---def test_get_registered_topics() -> None:- """Test getting registered topics returns a copy."""- TestTopic1 = create_topic(message_type=TestMessage)- TestTopic2 = create_topic(message_type=AnotherTestMessage)-- topics = PubSubTopicABC.get_registered_topics()-- assert TestTopic1 in topics- assert TestTopic2 in topics-- # Should be a copy, not the original- topics.clear()- assert len(PubSubTopicABC.get_registered_topics()) == 2---# ============================================================================-# Tests for PubSubTopicABC - Publishing & Subscribing-# ============================================================================--def test_topic_publish_and_subscribe(test_topic_instance: PubSubTopicABC[TestMessage]) -> None:- """Test basic publish and subscribe."""- # Get a subscription- sub = test_topic_instance.get_subscription()-- # Publish a message- msg = TestMessage(value=42)- test_topic_instance.publish(message=msg)-- # Should receive the message- received = sub.get(timeout=1)- assert isinstance(received, TestMessage)- assert received.value == 42---def test_topic_multiple_subscriptions(test_topic_instance: PubSubTopicABC[TestMessage]) -> None:- """Test multiple subscriptions receive the same message."""- sub1 = test_topic_instance.get_subscription()- sub2 = test_topic_instance.get_subscription()- sub3 = test_topic_instance.get_subscription()-- msg = TestMessage(value=99)- test_topic_instance.publish(message=msg)-- # All subscriptions should receive the message- for sub in [sub1, sub2, sub3]:- received = sub.get(timeout=1)- assert received.value == 99---def test_topic_publish_wrong_message_type(test_topic_instance: PubSubTopicABC[TestMessage]) -> None:- """Test that publishing wrong message type raises TypeError."""- wrong_msg = AnotherTestMessage(text="wrong")-- with pytest.raises(TypeError, match="Message must be of type TestMessage"):- test_topic_instance.publish(message=wrong_msg) # type: ignore---def test_topic_publication_queue(test_topic_instance: PubSubTopicABC[TestMessage]) -> None:- """Test that messages are also put in the publication queue."""- msg = TestMessage(value=123)- test_topic_instance.publish(message=msg)-- # Should be in the publication queue- received = test_topic_instance.publication.get(timeout=1)- assert received.value == 123---def test_topic_empty_subscriptions(test_topic_instance: PubSubTopicABC[TestMessage]) -> None:- """Test that subscription queues are empty before publishing."""- sub = test_topic_instance.get_subscription()-- # Should be empty- with pytest.raises(Empty):- sub.get(timeout=0.1)---def test_topic_close(test_topic_instance: PubSubTopicABC[TestMessage]) -> None:- """Test closing a topic."""- sub1 = test_topic_instance.get_subscription()- sub2 = test_topic_instance.get_subscription()-- assert len(test_topic_instance.subscriptions) == 2-- test_topic_instance.close()-- # Subscriptions should be cleared- assert len(test_topic_instance.subscriptions) == 0---# ============================================================================-# Tests for create_topic Factory-# ============================================================================--def test_create_topic_basic() -> None:- """Test create_topic factory creates a valid topic class."""- TestTopic = create_topic(message_type=TestMessage)-- # Should be a class, not an instance- assert isinstance(TestTopic, type)-- # Should be subclass of PubSubTopicABC- assert issubclass(TestTopic, PubSubTopicABC)-- # Should have correct message_type- instance = TestTopic()- assert instance.message_type == TestMessage---def test_create_topic_naming() -> None:- """Test that create_topic generates appropriate names."""- TestTopic = create_topic(message_type=TestMessage)-- # Should replace 'Message' with 'Topic'- assert TestTopic.__name__ == "TestTopic"---def test_create_topic_with_custom_publication_factory() -> None:- """Test create_topic with custom publication factory."""- custom_queue_created = False-- def custom_factory():- nonlocal custom_queue_created- custom_queue_created = True- return Queue()-- TestTopic = create_topic(- message_type=TestMessage,- publication_factory=custom_factory- )-- # Creating an instance should use the custom factory- instance = TestTopic()- assert custom_queue_created---# ============================================================================-# Tests for PubSubTopicManager-# ============================================================================--def test_manager_creation() -> None:- """Test manager creation and auto-instantiation of topics."""- # Create some topics- TestTopic1 = create_topic(message_type=TestMessage)- TestTopic2 = create_topic(message_type=AnotherTestMessage)-- # Create manager- manager = PubSubTopicManager.create()-- # Should have instantiated all registered topics- assert TestTopic1 in manager.topics- assert TestTopic2 in manager.topics- assert isinstance(manager.topics[TestTopic1], TestTopic1)- assert isinstance(manager.topics[TestTopic2], TestTopic2)---def test_manager_get_subscription() -> None:- """Test getting subscriptions through manager."""- TestTopic = create_topic(message_type=TestMessage)- manager = PubSubTopicManager.create()-- # Get subscription- sub = manager.get_subscription(topic_type=TestTopic)-- # Should be a valid queue- assert sub is not None---def test_manager_get_subscription_unknown_topic() -> None:- """Test getting subscription for unknown topic raises error."""- TestTopic = create_topic(message_type=TestMessage)- manager = PubSubTopicManager.create()-- # Create a topic that's not registered with this manager- class UnregisteredTopic(PubSubTopicABC[TestMessage]):- message_type: type[TestMessage] = TestMessage-- # Remove it from registry to simulate unknown topic- PubSubTopicABC.topic_registry.discard(UnregisteredTopic)-- with pytest.raises(ValueError, match="Unknown topic type"):- manager.get_subscription(topic_type=UnregisteredTopic)---def test_manager_publish() -> None:- """Test publishing through manager."""- TestTopic = create_topic(message_type=TestMessage)- manager = PubSubTopicManager.create()-- sub = manager.get_subscription(topic_type=TestTopic)-- msg = TestMessage(value=777)- manager.publish(topic_type=TestTopic, message=msg)-- received = sub.get(timeout=1)- assert received.value == 777---def test_manager_publish_unknown_topic() -> None:- """Test publishing to unknown topic raises error."""- TestTopic = create_topic(message_type=TestMessage)- manager = PubSubTopicManager.create()-- class UnregisteredTopic(PubSubTopicABC[TestMessage]):- message_type: type[TestMessage] = TestMessage-- PubSubTopicABC.topic_registry.discard(UnregisteredTopic)-- msg = TestMessage(value=1)-- with pytest.raises(ValueError, match="Unknown topic type"):- manager.publish(topic_type=UnregisteredTopic, message=msg)---def test_manager_close() -> None:- """Test closing manager closes all topics."""- TestTopic1 = create_topic(message_type=TestMessage)- TestTopic2 = create_topic(message_type=AnotherTestMessage)- manager = PubSubTopicManager.create()-- # Get some subscriptions to verify they exist- sub1 = manager.get_subscription(topic_type=TestTopic1)- sub2 = manager.get_subscription(topic_type=TestTopic2)-- assert len(manager.topics) == 2-- manager.close()-- # Topics should be cleared- assert len(manager.topics) == 0---# ============================================================================-# Tests for Pipeline Manager Registry-# ============================================================================--def test_create_pipeline_pubsub_manager() -> None:- """Test creating pipeline-specific managers."""- TestTopic = create_topic(message_type=TestMessage)-- pipeline_id = "test_pipeline_001"- manager = create_pipeline_pubsub_manager(pipeline_id=pipeline_id)-- # Should be registered- assert pipeline_id in PIPELINE_PUB_SUB_MANAGERS- assert PIPELINE_PUB_SUB_MANAGERS[pipeline_id] is manager-- # Should have topics- assert TestTopic in manager.topics---def test_create_pipeline_pubsub_manager_replaces_existing() -> None:- """Test that creating manager for same pipeline closes old one."""- TestTopic = create_topic(message_type=TestMessage)-- pipeline_id = "test_pipeline_002"-- # Create first manager- manager1 = create_pipeline_pubsub_manager(pipeline_id=pipeline_id)- sub1 = manager1.get_subscription(topic_type=TestTopic)-- # Create second manager for same pipeline- manager2 = create_pipeline_pubsub_manager(pipeline_id=pipeline_id)-- # Should be different instance- assert manager2 is not manager1-- # First manager should be closed- assert len(manager1.topics) == 0-- # Second manager should be active- assert TestTopic in manager2.topics---def test_multiple_pipeline_managers() -> None:- """Test multiple pipeline managers can coexist."""- TestTopic = create_topic(message_type=TestMessage)-- manager1 = create_pipeline_pubsub_manager(pipeline_id="pipeline_a")- manager2 = create_pipeline_pubsub_manager(pipeline_id="pipeline_b")-- # Both should be registered- assert "pipeline_a" in PIPELINE_PUB_SUB_MANAGERS- assert "pipeline_b" in PIPELINE_PUB_SUB_MANAGERS-- # Both should be independent- assert manager1 is not manager2-- # Both should have the topic- assert TestTopic in manager1.topics- assert TestTopic in manager2.topics---# ============================================================================-# Integration Tests-# ============================================================================--def test_full_pubsub_workflow() -> None:- """Test a complete pub/sub workflow."""- # Create message types and topics- TestTopic = create_topic(message_type=TestMessage)- AnotherTopic = create_topic(message_type=AnotherTestMessage)-- # Create manager- manager = PubSubTopicManager.create()-- # Get subscriptions- sub1 = manager.get_subscription(topic_type=TestTopic)- sub2 = manager.get_subscription(topic_type=TestTopic)- sub_other = manager.get_subscription(topic_type=AnotherTopic)-- # Publish messages- manager.publish(topic_type=TestTopic, message=TestMessage(value=100))- manager.publish(topic_type=TestTopic, message=TestMessage(value=200))- manager.publish(topic_type=AnotherTopic, message=AnotherTestMessage(text="hello"))-- # Verify subscriptions received correct messages- assert sub1.get(timeout=1).value == 100- assert sub1.get(timeout=1).value == 200-- assert sub2.get(timeout=1).value == 100- assert sub2.get(timeout=1).value == 200-- assert sub_other.get(timeout=1).text == "hello"-- # Queues should now be empty- with pytest.raises(Empty):- sub1.get(timeout=0.1)- with pytest.raises(Empty):- sub_other.get(timeout=0.1)-- # Clean up- manager.close()---def test_multiple_message_types_isolated() -> None:- """Test that different message types don't interfere."""- TestTopic = create_topic(message_type=TestMessage)- AnotherTopic = create_topic(message_type=AnotherTestMessage)-- manager = PubSubTopicManager.create()-- test_sub = manager.get_subscription(topic_type=TestTopic)- another_sub = manager.get_subscription(topic_type=AnotherTopic)-- # Publish to different topics- manager.publish(topic_type=TestTopic, message=TestMessage(value=42))- manager.publish(topic_type=AnotherTopic, message=AnotherTestMessage(text="world"))-- # Each subscription should only receive its own messages- test_msg = test_sub.get(timeout=1)- assert isinstance(test_msg, TestMessage)- assert test_msg.value == 42-- another_msg = another_sub.get(timeout=1)- assert isinstance(another_msg, AnotherTestMessage)- assert another_msg.text == "world"-- # Queues should be empty- with pytest.raises(Empty):- test_sub.get(timeout=0.1)- with pytest.raises(Empty):- another_sub.get(timeout=0.1)---# ============================================================================-# Edge Cases & Error Handling-# ============================================================================--def test_publish_before_subscription() -> None:- """Test that messages published before subscription are not received."""- TestTopic = create_topic(message_type=TestMessage)- manager = PubSubTopicManager.create()-- # Publish before subscribing- manager.publish(topic_type=TestTopic, message=TestMessage(value=1))-- # Now subscribe- sub = manager.get_subscription(topic_type=TestTopic)-- # Publish after subscribing- manager.publish(topic_type=TestTopic, message=TestMessage(value=2))-- # Should only receive the second message- received = sub.get(timeout=1)- assert received.value == 2-- # Queue should be empty- with pytest.raises(Empty):- sub.get(timeout=0.1)---def test_topic_instance_isolation() -> None:- """Test that different instances of same topic class are isolated."""- TestTopic = create_topic(message_type=TestMessage)-- instance1 = TestTopic()- instance2 = TestTopic()-- sub1 = instance1.get_subscription()- sub2 = instance2.get_subscription()-- # Publish to instance1- instance1.publish(message=TestMessage(value=111))-- # Only sub1 should receive- assert sub1.get(timeout=1).value == 111-- with pytest.raises(Empty):- sub2.get(timeout=0.1)diff --git a/freemocap/tests/test_schema_contract.py b/freemocap/tests/test_schema_contract.pynew file mode 100644index 00000000..b17e29ea--- /dev/null+++ b/freemocap/tests/test_schema_contract.py@@ -0,0 +1,443 @@+"""+Schema contract tests: verify backend Pydantic models serialize to the shapes+the frontend TypeScript types expect.++These catch field name drift, missing fields, and default value mismatches+between the Python backend and the React frontend.+"""+import pytest++from freemocap.app.settings import (+ CalibrationSettings,+ CameraState,+ CameraStatus,+ FreeMoCapSettings,+ MocapSettings,+ PipelineSettings,+ SettingsManager,+ VMCSettings,+)+from freemocap.core.pipeline.pipeline_configs import (+ CalibrationPipelineConfig,+ CalibrationSolverMethod,+ MocapPipelineConfig,+ RealtimePipelineConfig,+)+from freemocap.core.mocap.skeleton_dewiggler.realtime_skeleton_filter import RealtimeFilterConfig+from freemocap.core.mocap.skeleton_dewiggler.dewiggling_methods.bone_length_estimator import EstimatorConfig+++# ---------------------------------------------------------------------------+# Top-level settings blob+# ---------------------------------------------------------------------------+++class TestFreeMoCapSettingsSchema:+ """Verify the top-level FreeMoCapSettings matches the frontend+ FreeMoCapSettings interface in settings-types.ts."""++ def test_has_expected_top_level_keys(self) -> None:+ dumped = FreeMoCapSettings().model_dump()+ expected_keys = {"cameras", "pipeline", "calibration", "mocap", "vmc"}+ assert set(dumped.keys()) == expected_keys++ def test_cameras_defaults_to_empty_dict(self) -> None:+ dumped = FreeMoCapSettings().model_dump()+ assert dumped["cameras"] == {}++ def test_pipeline_is_dict(self) -> None:+ dumped = FreeMoCapSettings().model_dump()+ assert isinstance(dumped["pipeline"], dict)++ def test_calibration_is_dict(self) -> None:+ dumped = FreeMoCapSettings().model_dump()+ assert isinstance(dumped["calibration"], dict)++ def test_mocap_is_dict(self) -> None:+ dumped = FreeMoCapSettings().model_dump()+ assert isinstance(dumped["mocap"], dict)+++# ---------------------------------------------------------------------------+# Calibration settings+# ---------------------------------------------------------------------------+++class TestCalibrationSettingsSchema:+ """Verify CalibrationSettings matches the frontend+ BackendCalibrationSettings interface."""++ EXPECTED_KEYS = {+ "config",+ "is_recording",+ "recording_progress",+ "last_recording_path",+ "has_calibration_toml",+ }++ def test_has_expected_keys(self) -> None:+ dumped = CalibrationSettings().model_dump()+ assert set(dumped.keys()) == self.EXPECTED_KEYS++ def test_default_is_recording_false(self) -> None:+ dumped = CalibrationSettings().model_dump()+ assert dumped["is_recording"] is False++ def test_default_recording_progress_zero(self) -> None:+ dumped = CalibrationSettings().model_dump()+ assert dumped["recording_progress"] == 0.0++ def test_default_last_recording_path_none(self) -> None:+ dumped = CalibrationSettings().model_dump()+ assert dumped["last_recording_path"] is None++ def test_default_has_calibration_toml_false(self) -> None:+ dumped = CalibrationSettings().model_dump()+ assert dumped["has_calibration_toml"] is False+++class TestCalibrationConfigSchema:+ """Verify CalibrationPipelineConfig serializes to the shape+ the frontend BackendCalibrationConfig interface expects.++ The frontend settings-types.ts uses snake_case field names,+ which is what model_dump() produces by default."""++ EXPECTED_KEYS = {+ "calibration_recording_folder",+ "charuco_board_x_squares",+ "charuco_board_y_squares",+ "charuco_square_length",+ "solver_method",+ "use_groundplane",+ "pyceres_solver_config",+ }++ def test_has_expected_keys(self) -> None:+ dumped = CalibrationPipelineConfig().model_dump()+ assert set(dumped.keys()) == self.EXPECTED_KEYS++ def test_by_alias_produces_camel_case(self) -> None:+ """The HTTP endpoints receive camelCase from frontend thunks.+ Verify by_alias=True produces the expected alias names."""+ dumped = CalibrationPipelineConfig().model_dump(by_alias=True)+ assert "charucoBoardXSquares" in dumped+ assert "charucoBoardYSquares" in dumped+ assert "charucoSquareLength" in dumped+ assert "solverMethod" in dumped+ assert "useGroundplane" in dumped++ def test_default_charuco_board_x_squares(self) -> None:+ """Frontend initialState has charucoBoardXSquares: 5."""+ config = CalibrationPipelineConfig()+ assert config.charuco_board_x_squares == 5++ def test_default_charuco_board_y_squares(self) -> None:+ """Frontend initialState has charucoBoardYSquares: 3."""+ config = CalibrationPipelineConfig()+ assert config.charuco_board_y_squares == 3++ def test_default_charuco_square_length(self) -> None:+ """Frontend initialState has charucoSquareLength: 1."""+ config = CalibrationPipelineConfig()+ assert config.charuco_square_length == 1++ def test_default_solver_method(self) -> None:+ """Frontend initialState has solverMethod: 'anipose'."""+ config = CalibrationPipelineConfig()+ assert config.solver_method == CalibrationSolverMethod.ANIPOSE+ assert config.solver_method.value == "anipose"++ def test_default_use_groundplane(self) -> None:+ """Frontend initialState has useGroundplane: false."""+ config = CalibrationPipelineConfig()+ assert config.use_groundplane is False++ def test_roundtrip_snake_case(self) -> None:+ """model_dump() → model_validate() round-trips cleanly with snake_case.+ This is the path used by SettingsManager.apply_patch."""+ original = CalibrationPipelineConfig()+ dumped = original.model_dump()+ restored = CalibrationPipelineConfig.model_validate(dumped)+ assert restored.charuco_board_x_squares == original.charuco_board_x_squares+ assert restored.charuco_board_y_squares == original.charuco_board_y_squares+ assert restored.solver_method == original.solver_method++ def test_roundtrip_camel_case(self) -> None:+ """model_dump(by_alias=True) → model_validate() round-trips cleanly+ with camelCase aliases. This is the path used by HTTP endpoints."""+ original = CalibrationPipelineConfig()+ dumped = original.model_dump(by_alias=True)+ restored = CalibrationPipelineConfig.model_validate(dumped)+ assert restored.charuco_board_x_squares == original.charuco_board_x_squares+++# ---------------------------------------------------------------------------+# Mocap settings+# ---------------------------------------------------------------------------+++class TestMocapSettingsSchema:+ """Verify MocapSettings matches the frontend BackendMocapSettings."""++ EXPECTED_KEYS = {+ "config",+ "is_recording",+ "recording_progress",+ "last_recording_path",+ }++ def test_has_expected_keys(self) -> None:+ dumped = MocapSettings().model_dump()+ assert set(dumped.keys()) == self.EXPECTED_KEYS++ def test_default_is_recording_false(self) -> None:+ dumped = MocapSettings().model_dump()+ assert dumped["is_recording"] is False+++class TestMocapConfigSchema:+ """Verify MocapPipelineConfig matches the frontend BackendMocapConfig."""++ EXPECTED_KEYS = {"detector", "skeleton_filter"}++ def test_has_expected_keys(self) -> None:+ config = MocapPipelineConfig.default_realtime()+ dumped = config.model_dump()+ assert set(dumped.keys()) == self.EXPECTED_KEYS++ def test_detector_is_dict(self) -> None:+ config = MocapPipelineConfig.default_realtime()+ dumped = config.model_dump()+ assert isinstance(dumped["detector"], dict)++ def test_skeleton_filter_is_dict(self) -> None:+ config = MocapPipelineConfig.default_realtime()+ dumped = config.model_dump()+ assert isinstance(dumped["skeleton_filter"], dict)+++class TestRealtimeFilterConfigSchema:+ """Verify RealtimeFilterConfig matches the frontend BackendRealtimeFilterConfig."""++ EXPECTED_KEYS = {+ "min_cutoff",+ "beta",+ "d_cutoff",+ "fabrik_tolerance",+ "fabrik_max_iterations",+ "height_meters",+ "noise_sigma",+ "estimator_config",+ "max_reprojection_error_px",+ "max_velocity_m_per_s",+ "max_rejected_streak",+ "max_prediction_frames",+ "prediction_velocity_decay",+ }++ def test_has_expected_keys(self) -> None:+ dumped = RealtimeFilterConfig().model_dump()+ assert set(dumped.keys()) == self.EXPECTED_KEYS++ def test_estimator_config_keys(self) -> None:+ """Frontend BackendEstimatorConfig expects these three fields."""+ dumped = RealtimeFilterConfig().model_dump()+ estimator = dumped["estimator_config"]+ assert set(estimator.keys()) == {+ "max_samples",+ "min_samples_for_full_confidence",+ "iqr_confidence_sensitivity",+ }++ def test_default_min_cutoff_matches_frontend(self) -> None:+ """Frontend DEFAULT_REALTIME_FILTER_CONFIG has min_cutoff: 0.005."""+ assert RealtimeFilterConfig().min_cutoff == 0.005++ def test_default_beta_matches_frontend(self) -> None:+ """Frontend DEFAULT_REALTIME_FILTER_CONFIG has beta: 0.3."""+ assert RealtimeFilterConfig().beta == 0.3++ def test_default_d_cutoff_matches_frontend(self) -> None:+ """Frontend DEFAULT_REALTIME_FILTER_CONFIG has d_cutoff: 1.0."""+ assert RealtimeFilterConfig().d_cutoff == 1.0++ def test_default_fabrik_tolerance_matches_frontend(self) -> None:+ """Frontend DEFAULT_REALTIME_FILTER_CONFIG has fabrik_tolerance: 1e-4."""+ assert RealtimeFilterConfig().fabrik_tolerance == 1e-4++ def test_default_fabrik_max_iterations_matches_frontend(self) -> None:+ """Frontend DEFAULT_REALTIME_FILTER_CONFIG has fabrik_max_iterations: 20."""+ assert RealtimeFilterConfig().fabrik_max_iterations == 20++ def test_default_height_meters_matches_frontend(self) -> None:+ """Frontend DEFAULT_REALTIME_FILTER_CONFIG has height_meters: 1.75."""+ assert RealtimeFilterConfig().height_meters == 1.75++ def test_default_noise_sigma_matches_frontend(self) -> None:+ """Frontend DEFAULT_REALTIME_FILTER_CONFIG has noise_sigma: 0.015."""+ assert RealtimeFilterConfig().noise_sigma == 0.015++ def test_default_max_reprojection_error_matches_frontend(self) -> None:+ """Frontend DEFAULT_REALTIME_FILTER_CONFIG has max_reprojection_error_px: 60.0."""+ assert RealtimeFilterConfig().max_reprojection_error_px == 60.0++ def test_default_max_velocity_matches_frontend(self) -> None:+ """Frontend DEFAULT_REALTIME_FILTER_CONFIG has max_velocity_m_per_s: 50.0."""+ assert RealtimeFilterConfig().max_velocity_m_per_s == 50.0++ def test_default_max_rejected_streak_matches_frontend(self) -> None:+ """Frontend DEFAULT_REALTIME_FILTER_CONFIG has max_rejected_streak: 5."""+ assert RealtimeFilterConfig().max_rejected_streak == 5++ def test_default_max_prediction_frames_matches_frontend(self) -> None:+ """Frontend DEFAULT_REALTIME_FILTER_CONFIG has max_prediction_frames: 15."""+ assert RealtimeFilterConfig().max_prediction_frames == 15++ def test_default_prediction_velocity_decay_matches_frontend(self) -> None:+ """Frontend DEFAULT_REALTIME_FILTER_CONFIG has prediction_velocity_decay: 0.75."""+ assert RealtimeFilterConfig().prediction_velocity_decay == 0.75+++class TestEstimatorConfigDefaults:+ """Verify EstimatorConfig defaults match frontend DEFAULT_ESTIMATOR_CONFIG."""++ def test_default_max_samples(self) -> None:+ assert EstimatorConfig().max_samples == 500++ def test_default_min_samples_for_full_confidence(self) -> None:+ assert EstimatorConfig().min_samples_for_full_confidence == 100++ def test_default_iqr_confidence_sensitivity(self) -> None:+ assert EstimatorConfig().iqr_confidence_sensitivity == 10.0+++# ---------------------------------------------------------------------------+# Pipeline settings+# ---------------------------------------------------------------------------+++class TestPipelineSettingsSchema:+ """Verify PipelineSettings matches the frontend BackendPipelineSettings."""++ EXPECTED_KEYS = {+ "config",+ "is_connected",+ "pipeline_id",+ "camera_group_id",+ "is_paused",+ }++ def test_has_expected_keys(self) -> None:+ dumped = PipelineSettings().model_dump()+ assert set(dumped.keys()) == self.EXPECTED_KEYS++ def test_default_is_connected_false(self) -> None:+ dumped = PipelineSettings().model_dump()+ assert dumped["is_connected"] is False++ def test_default_is_paused_false(self) -> None:+ dumped = PipelineSettings().model_dump()+ assert dumped["is_paused"] is False+++# ---------------------------------------------------------------------------+# Camera state+# ---------------------------------------------------------------------------+++class TestCameraStateSchema:+ """Verify CameraState matches the frontend BackendCameraState."""++ def test_has_config_and_status(self) -> None:+ # CameraState requires a CameraConfig — we just check it has the right top-level shape+ from skellycam.core.camera.config.camera_config import CameraConfig++ state = CameraState(config=CameraConfig(camera_id="0"), status=CameraStatus.CONNECTED)+ dumped = state.model_dump()+ assert "config" in dumped+ assert "status" in dumped++ def test_status_values_match_frontend(self) -> None:+ """Frontend BackendCameraStatus = "disconnected" | "connected" | "error"."""+ assert CameraStatus.DISCONNECTED.value == "disconnected"+ assert CameraStatus.CONNECTED.value == "connected"+ assert CameraStatus.ERROR.value == "error"+++# ---------------------------------------------------------------------------+# Settings state message (WebSocket)+# ---------------------------------------------------------------------------+++class TestSettingsStateMessageFormat:+ """Verify the WebSocket settings/state message has the shape+ the frontend isSettingsStateMessage() type guard expects."""++ def test_has_required_fields(self) -> None:+ manager = SettingsManager()+ msg = manager.get_state_message()+ assert msg["message_type"] == "settings/state"+ assert isinstance(msg["settings"], dict)+ assert isinstance(msg["version"], int)++ def test_settings_field_is_full_blob(self) -> None:+ manager = SettingsManager()+ msg = manager.get_state_message()+ settings = msg["settings"]+ assert "cameras" in settings+ assert "pipeline" in settings+ assert "calibration" in settings+ assert "mocap" in settings++ def test_initial_version_is_zero(self) -> None:+ manager = SettingsManager()+ msg = manager.get_state_message()+ assert msg["version"] == 0+++# ---------------------------------------------------------------------------+# Calibration solver method enum+# ---------------------------------------------------------------------------+++# ---------------------------------------------------------------------------+# VMC settings+# ---------------------------------------------------------------------------+++class TestVMCSettingsSchema:+ """Verify VMCSettings matches the frontend (once a frontend VMC type is added)."""++ EXPECTED_KEYS = {"enabled", "host", "port"}++ def test_has_expected_keys(self) -> None:+ dumped = VMCSettings().model_dump()+ assert set(dumped.keys()) == self.EXPECTED_KEYS++ def test_default_enabled_false(self) -> None:+ assert VMCSettings().enabled is False++ def test_default_host(self) -> None:+ assert VMCSettings().host == "127.0.0.1"++ def test_default_port(self) -> None:+ assert VMCSettings().port == 39539+++# ---------------------------------------------------------------------------+# Calibration solver method enum+# ---------------------------------------------------------------------------+++class TestCalibrationSolverMethodEnum:+ """Verify the enum values match frontend CalibrationSolverMethod type."""++ def test_anipose_value(self) -> None:+ assert CalibrationSolverMethod.ANIPOSE.value == "anipose"++ def test_pyceres_value(self) -> None:+ assert CalibrationSolverMethod.PYCERES.value == "pyceres"++ def test_only_two_members(self) -> None:+ assert len(CalibrationSolverMethod) == 2\ No newline at end of filediff --git a/freemocap/tests/test_settings_manager.py b/freemocap/tests/test_settings_manager.pynew file mode 100644index 00000000..0bf6993b--- /dev/null+++ b/freemocap/tests/test_settings_manager.py@@ -0,0 +1,345 @@+"""+SettingsManager unit tests: patch logic, version tracking, deep merge,+and async change notification.+"""+import asyncio+import copy++import pytest++from freemocap.app.settings import (+ CalibrationSettings,+ FreeMoCapSettings,+ MocapSettings,+ SettingsManager,+ _deep_merge,+)+++# ---------------------------------------------------------------------------+# _deep_merge+# ---------------------------------------------------------------------------+++class TestDeepMerge:++ def test_scalar_overwrite(self) -> None:+ base = {"a": 1, "b": 2}+ patch = {"b": 99}+ result = _deep_merge(base=base, patch=patch)+ assert result == {"a": 1, "b": 99}++ def test_nested_merge(self) -> None:+ base = {"outer": {"a": 1, "b": 2}}+ patch = {"outer": {"b": 99}}+ result = _deep_merge(base=base, patch=patch)+ assert result == {"outer": {"a": 1, "b": 99}}++ def test_deeply_nested_merge(self) -> None:+ base = {"l1": {"l2": {"l3": {"keep": True, "change": False}}}}+ patch = {"l1": {"l2": {"l3": {"change": True}}}}+ result = _deep_merge(base=base, patch=patch)+ assert result["l1"]["l2"]["l3"]["keep"] is True+ assert result["l1"]["l2"]["l3"]["change"] is True++ def test_adds_new_keys(self) -> None:+ base = {"a": 1}+ patch = {"b": 2}+ result = _deep_merge(base=base, patch=patch)+ assert result == {"a": 1, "b": 2}++ def test_does_not_mutate_base(self) -> None:+ base = {"outer": {"a": 1}}+ base_copy = copy.deepcopy(base)+ _deep_merge(base=base, patch={"outer": {"a": 99}})+ assert base == base_copy++ def test_does_not_mutate_patch(self) -> None:+ patch = {"outer": {"a": 99}}+ patch_copy = copy.deepcopy(patch)+ _deep_merge(base={"outer": {"a": 1}}, patch=patch)+ assert patch == patch_copy++ def test_empty_patch_returns_base_copy(self) -> None:+ base = {"a": 1}+ result = _deep_merge(base=base, patch={})+ assert result == base+ assert result is not base++ def test_empty_base(self) -> None:+ result = _deep_merge(base={}, patch={"a": 1})+ assert result == {"a": 1}++ def test_replaces_dict_with_scalar(self) -> None:+ """If patch has a scalar where base has a dict, scalar wins."""+ base = {"a": {"nested": True}}+ patch = {"a": "replaced"}+ result = _deep_merge(base=base, patch=patch)+ assert result["a"] == "replaced"+++# ---------------------------------------------------------------------------+# SettingsManager: initial state+# ---------------------------------------------------------------------------+++class TestSettingsManagerInitialState:++ def test_initial_version_is_zero(self) -> None:+ manager = SettingsManager()+ assert manager.version == 0++ def test_initial_settings_is_default(self) -> None:+ manager = SettingsManager()+ assert manager.settings == FreeMoCapSettings()++ def test_initial_cameras_empty(self) -> None:+ manager = SettingsManager()+ assert manager.settings.cameras == {}++ def test_initial_calibration_not_recording(self) -> None:+ manager = SettingsManager()+ assert manager.settings.calibration.is_recording is False++ def test_initial_mocap_not_recording(self) -> None:+ manager = SettingsManager()+ assert manager.settings.mocap.is_recording is False+++# ---------------------------------------------------------------------------+# SettingsManager: apply_patch+# ---------------------------------------------------------------------------+++class TestSettingsManagerApplyPatch:++ def test_bumps_version(self) -> None:+ manager = SettingsManager()+ assert manager.version == 0+ manager.apply_patch({"calibration": {"is_recording": True}})+ assert manager.version == 1+ manager.apply_patch({"calibration": {"is_recording": False}})+ assert manager.version == 2++ def test_patch_calibration_recording_status(self) -> None:+ manager = SettingsManager()+ manager.apply_patch({"calibration": {"is_recording": True}})+ assert manager.settings.calibration.is_recording is True++ def test_patch_calibration_config_field(self) -> None:+ manager = SettingsManager()+ manager.apply_patch({+ "calibration": {"config": {"charuco_board_x_squares": 7}},+ })+ assert manager.settings.calibration.config.charuco_board_x_squares == 7++ def test_patch_preserves_sibling_fields(self) -> None:+ """Patching charuco_board_x_squares should not clobber charuco_board_y_squares."""+ manager = SettingsManager()+ original_y = manager.settings.calibration.config.charuco_board_y_squares+ manager.apply_patch({+ "calibration": {"config": {"charuco_board_x_squares": 7}},+ })+ assert manager.settings.calibration.config.charuco_board_y_squares == original_y++ def test_patch_preserves_unrelated_sections(self) -> None:+ """Patching calibration should not touch mocap."""+ manager = SettingsManager()+ original_mocap = manager.settings.mocap.model_dump()+ manager.apply_patch({"calibration": {"is_recording": True}})+ assert manager.settings.mocap.model_dump() == original_mocap++ def test_patch_mocap_config(self) -> None:+ manager = SettingsManager()+ manager.apply_patch({+ "mocap": {"is_recording": True},+ })+ assert manager.settings.mocap.is_recording is True++ def test_patch_returns_new_settings(self) -> None:+ manager = SettingsManager()+ result = manager.apply_patch({"calibration": {"is_recording": True}})+ assert isinstance(result, FreeMoCapSettings)+ assert result.calibration.is_recording is True++ def test_patch_with_invalid_data_raises(self) -> None:+ """Pydantic validation should reject nonsense values."""+ manager = SettingsManager()+ original_version = manager.version+ with pytest.raises(Exception):+ manager.apply_patch({"calibration": "not_a_dict"})+ # Version should NOT have bumped on failure+ assert manager.version == original_version++ def test_patch_with_invalid_data_preserves_state(self) -> None:+ manager = SettingsManager()+ original = manager.settings.model_dump()+ try:+ manager.apply_patch({"calibration": "not_a_dict"})+ except Exception:+ pass+ assert manager.settings.model_dump() == original+++# ---------------------------------------------------------------------------+# SettingsManager: get_state_message+# ---------------------------------------------------------------------------+++class TestSettingsManagerGetStateMessage:++ def test_message_type(self) -> None:+ manager = SettingsManager()+ msg = manager.get_state_message()+ assert msg["message_type"] == "settings/state"++ def test_includes_version(self) -> None:+ manager = SettingsManager()+ msg = manager.get_state_message()+ assert msg["version"] == 0++ def test_version_reflects_patches(self) -> None:+ manager = SettingsManager()+ manager.apply_patch({"calibration": {"is_recording": True}})+ msg = manager.get_state_message()+ assert msg["version"] == 1++ def test_settings_is_serializable_dict(self) -> None:+ manager = SettingsManager()+ msg = manager.get_state_message()+ settings = msg["settings"]+ assert isinstance(settings, dict)+ assert "cameras" in settings+ assert "pipeline" in settings+ assert "calibration" in settings+ assert "mocap" in settings+++# ---------------------------------------------------------------------------+# SettingsManager: update_calibration_status+# ---------------------------------------------------------------------------+++class TestSettingsManagerCalibrationStatus:++ def test_set_is_recording(self) -> None:+ manager = SettingsManager()+ manager.update_calibration_status(is_recording=True)+ assert manager.settings.calibration.is_recording is True++ def test_set_recording_progress(self) -> None:+ manager = SettingsManager()+ manager.update_calibration_status(recording_progress=42.5)+ assert manager.settings.calibration.recording_progress == 42.5++ def test_set_last_recording_path(self) -> None:+ manager = SettingsManager()+ manager.update_calibration_status(last_recording_path="/tmp/cal")+ assert manager.settings.calibration.last_recording_path == "/tmp/cal"++ def test_set_has_calibration_toml(self) -> None:+ manager = SettingsManager()+ manager.update_calibration_status(has_calibration_toml=True)+ assert manager.settings.calibration.has_calibration_toml is True++ def test_bumps_version(self) -> None:+ manager = SettingsManager()+ manager.update_calibration_status(is_recording=True)+ assert manager.version == 1++ def test_none_args_leave_fields_unchanged(self) -> None:+ manager = SettingsManager()+ manager.update_calibration_status(is_recording=True)+ manager.update_calibration_status(recording_progress=50.0)+ assert manager.settings.calibration.is_recording is True+++# ---------------------------------------------------------------------------+# SettingsManager: update_mocap_status+# ---------------------------------------------------------------------------+++class TestSettingsManagerMocapStatus:++ def test_set_is_recording(self) -> None:+ manager = SettingsManager()+ manager.update_mocap_status(is_recording=True)+ assert manager.settings.mocap.is_recording is True++ def test_set_recording_progress(self) -> None:+ manager = SettingsManager()+ manager.update_mocap_status(recording_progress=75.0)+ assert manager.settings.mocap.recording_progress == 75.0++ def test_set_last_recording_path(self) -> None:+ manager = SettingsManager()+ manager.update_mocap_status(last_recording_path="/tmp/mocap")+ assert manager.settings.mocap.last_recording_path == "/tmp/mocap"++ def test_bumps_version(self) -> None:+ manager = SettingsManager()+ manager.update_mocap_status(is_recording=True)+ assert manager.version == 1+++# ---------------------------------------------------------------------------+# SettingsManager: async change notification+# ---------------------------------------------------------------------------+++class TestSettingsManagerChangeNotification:++ @pytest.mark.asyncio+ async def test_notify_changed_wakes_waiter(self) -> None:+ manager = SettingsManager()+ woke_up = False++ async def waiter() -> None:+ nonlocal woke_up+ await manager.wait_for_change()+ woke_up = True++ task = asyncio.create_task(waiter())+ await asyncio.sleep(0.01) # Let the waiter start waiting+ assert not woke_up++ manager.notify_changed()+ await asyncio.sleep(0.01) # Let the waiter wake+ assert woke_up+ await task++ @pytest.mark.asyncio+ async def test_apply_patch_wakes_waiter(self) -> None:+ manager = SettingsManager()+ woke_up = False++ async def waiter() -> None:+ nonlocal woke_up+ await manager.wait_for_change()+ woke_up = True++ task = asyncio.create_task(waiter())+ await asyncio.sleep(0.01)++ manager.apply_patch({"calibration": {"is_recording": True}})+ await asyncio.sleep(0.01)+ assert woke_up+ await task++ @pytest.mark.asyncio+ async def test_update_status_wakes_waiter(self) -> None:+ manager = SettingsManager()+ woke_up = False++ async def waiter() -> None:+ nonlocal woke_up+ await manager.wait_for_change()+ woke_up = True++ task = asyncio.create_task(waiter())+ await asyncio.sleep(0.01)++ manager.update_calibration_status(is_recording=True)+ await asyncio.sleep(0.01)+ assert woke_up+ await taskdiff --git a/freemocap/tests/test_skeleton_data_shape.py b/freemocap/tests/test_skeleton_data_shape.pydeleted file mode 100644index aa08c35b..00000000--- a/freemocap/tests/test_skeleton_data_shape.py+++ /dev/null@@ -1,73 +0,0 @@-from pathlib import Path-from typing import Union--import numpy as np-import pytest--from freemocap.utilities.get_number_of_frames_of_videos_in_a_folder import (- get_number_of_frames_of_videos_in_a_folder,-)--[email protected]("raw_skeleton_data", "reprojection_error_data")-def test_skeleton_data_exists(- raw_skeleton_data: Union[str, Path],- reprojection_error_data: Union[str, Path],-):- """- test that the `3d detection` process worked correctly by checking that there is an `.npy` file containing the 3d data in the `output_data_folder`- """-- assert Path(- raw_skeleton_data- ).is_file(), f"3d skeleton data file does not exist at {raw_skeleton_data}"-- assert Path(- reprojection_error_data- ).is_file(), f"3d skeleton reprojection error data file does not exist at {reprojection_error_data}"--[email protected]("synchronized_video_folder_path", "raw_skeleton_data", "reprojection_error_data")-def test_skeleton_data_shape(- synchronized_video_folder_path: Union[str, Path],- raw_skeleton_data: Union[str, Path, np.ndarray],- reprojection_error_data: Union[str, Path, np.ndarray],-):- """- test that the `3d detection` process worked correctly by checking:- 1. Dimensions of the raw skeleton numpy array are correct- 2. Dimensions of the reprojection error numpy array are correct- """- if isinstance(raw_skeleton_data, (str, Path)):- skel3d_frame_marker_xyz = np.load(raw_skeleton_data)- else:- skel3d_frame_marker_xyz = raw_skeleton_data-- assert (- len(skel3d_frame_marker_xyz.shape) == 3- ), f"3d skeleton data file should have 3 dimensions, but has shape {skel3d_frame_marker_xyz.shape}"-- if isinstance(reprojection_error_data, (str, Path)):- skeleton_reprojection_error_fr_mar = np.load(reprojection_error_data)- else:- skeleton_reprojection_error_fr_mar = reprojection_error_data-- assert (- len(skeleton_reprojection_error_fr_mar.shape) == 2- ), f"3d skeleton reprojection error data file should have 2 dimensions but has shape {skeleton_reprojection_error_fr_mar.shape}"-- frame_counts = list(get_number_of_frames_of_videos_in_a_folder(synchronized_video_folder_path).values())- assert (- len(set(frame_counts)) == 1- ), f"Videos in {synchronized_video_folder_path} have different frame counts: {frame_counts}"-- number_of_frames = frame_counts[0]-- assert skel3d_frame_marker_xyz.shape[0] == number_of_frames- assert skeleton_reprojection_error_fr_mar.shape[0] == number_of_frames-- # TODO - check number of tracked points vs 'expected' number of tracked points-- assert (- skel3d_frame_marker_xyz.shape[2] == 3- ), f"3d skeleton data file should have 3 dimensions for X,Y,Z, but instead has {skel3d_frame_marker_xyz.shape[2]}"diff --git a/freemocap/tests/test_synchronized_video_frame_counts.py b/freemocap/tests/test_synchronized_video_frame_counts.pydeleted file mode 100644index 371714e6..00000000--- a/freemocap/tests/test_synchronized_video_frame_counts.py+++ /dev/null@@ -1,25 +0,0 @@-from pathlib import Path-from typing import Union--import pytest--from freemocap.utilities.get_number_of_frames_of_videos_in_a_folder import (- get_number_of_frames_of_videos_in_a_folder,-)-from freemocap.utilities.get_video_paths import get_video_paths--[email protected]("synchronized_video_folder_path")-def test_synchronized_video_frame_counts(synchronized_video_folder_path: Union[Path, str]):- """- Test if all the videos in this folder have precisely the same number of frames- """- list_of_video_paths = get_video_paths(Path(synchronized_video_folder_path))-- assert len(list_of_video_paths) > 0, f"No videos found in {synchronized_video_folder_path}"-- frame_counts = list(get_number_of_frames_of_videos_in_a_folder(synchronized_video_folder_path).values())-- assert (- len(set(frame_counts)) == 1- ), f"Videos in {synchronized_video_folder_path} have different frame counts: {frame_counts}"diff --git a/freemocap/tests/test_total_body_center_of_mass_data_shape.py b/freemocap/tests/test_total_body_center_of_mass_data_shape.pydeleted file mode 100644index a3b148c6..00000000--- a/freemocap/tests/test_total_body_center_of_mass_data_shape.py+++ /dev/null@@ -1,44 +0,0 @@-from pathlib import Path-from typing import Union--import numpy as np-import pytest--from freemocap.utilities.get_number_of_frames_of_videos_in_a_folder import (- get_number_of_frames_of_videos_in_a_folder,-)--[email protected]("total_body_center_of_mass_data")-def test_total_body_center_of_mass_data_exists(- total_body_center_of_mass_data: Union[str, Path],-):- assert Path(- total_body_center_of_mass_data- ).is_file(), f"No file found at {total_body_center_of_mass_data}"--[email protected]("synchronized_video_folder_path", "total_body_center_of_mass_data")-def test_total_body_center_of_mass_data_shape(- synchronized_video_folder_path: Union[str, Path],- total_body_center_of_mass_data: Union[str, Path, np.ndarray],-):- if isinstance(total_body_center_of_mass_data, (str, Path)):- total_body_center_of_mass_fr_xyz = np.load(total_body_center_of_mass_data)- else:- total_body_center_of_mass_fr_xyz = total_body_center_of_mass_data-- frame_counts = list(get_number_of_frames_of_videos_in_a_folder(synchronized_video_folder_path).values())- assert (- len(set(frame_counts)) == 1- ), f"Videos in {synchronized_video_folder_path} have different frame counts: {frame_counts}"-- number_of_frames = frame_counts[0]-- assert (- total_body_center_of_mass_fr_xyz.shape[0] == number_of_frames- ), f"Number of frames in {total_body_center_of_mass_fr_xyz.shape} does not match number of frames of videos in {synchronized_video_folder_path}"-- assert (- total_body_center_of_mass_fr_xyz.shape[1] == 3- ), f"total body center of mass should have 3 dimensions (X,Y,Z) but has {total_body_center_of_mass_fr_xyz.shape[1]}"diff --git a/freemocap/tests/test_triangulator.py b/freemocap/tests/test_triangulator.pydeleted file mode 100644index 970961de..00000000--- a/freemocap/tests/test_triangulator.py+++ /dev/null@@ -1,712 +0,0 @@-import tempfile-from pathlib import Path--import cv2-import numpy as np-import pytest-import toml--from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.camera_math_models import (- CameraDistortionCoefficients,- CameraMatrix,-)-from freemocap.core.pipeline.posthoc_pipelines.posthoc_calibration_pipeline.calibration_helpers.point_triangulator import CameraCalibrationData, PointTriangulator---class SyntheticCameraSetup:- """Helper class to generate synthetic multi-camera calibration data."""-- def __init__(- self,- num_cameras: int,- image_width: int = 1920,- image_height: int = 1080,- focal_length: float = 1000.0,- baseline: float = 0.5,- noise_std: float = 0.0,- ):- self.num_cameras = num_cameras- self.image_width = image_width- self.image_height = image_height- self.focal_length = focal_length- self.baseline = baseline- self.noise_std = noise_std-- self.camera_calibrations = self._create_cameras()-- def _create_cameras(self) -> dict[str, CameraCalibrationData]:- """Create synthetic cameras in a standard stereo/multi-camera configuration."""- cameras: dict[str, CameraCalibrationData] = {}-- for i in range(self.num_cameras):- camera_id = f"cam_{i:02d}"-- # Arrange cameras horizontally along X-axis- # Cameras are evenly spaced and all look in +Z direction- if self.num_cameras == 1:- x = 0.0- else:- # Spread cameras symmetrically around X=0- x = (i - (self.num_cameras - 1) / 2) * self.baseline-- y = 0.0- z = 0.0 # Cameras on the X-Y plane at Z=0-- camera_position = np.array([x, y, z], dtype=np.float64)-- # All cameras look in +Z direction (forward)- # Standard camera orientation: X right, Y down, Z forward- rotation_matrix = np.eye(3, dtype=np.float64)-- # Convert rotation matrix to OpenCV rotation vector- rotation_vector = cv2.Rodrigues(rotation_matrix)[0].ravel()-- # Translation: position of world origin in camera coordinates- # t = -R @ camera_position- translation = -rotation_matrix @ camera_position-- # Camera intrinsics- camera_matrix = CameraMatrix(- matrix=np.array(- [- [self.focal_length, 0, self.image_width / 2],- [0, self.focal_length, self.image_height / 2],- [0, 0, 1],- ],- dtype=np.float64,- )- )-- # No distortion for simplicity- distortion = CameraDistortionCoefficients(- coefficients=np.zeros(5, dtype=np.float64)- )-- cameras[camera_id] = CameraCalibrationData(- name=camera_id,- image_size=(self.image_width, self.image_height),- matrix=camera_matrix,- distortion=distortion,- rotation_vector=rotation_vector,- translation=translation,- )-- return cameras-- def project_points(- self, points3d: np.ndarray- ) -> dict[str, np.ndarray]:- """- Project 3D points to 2D in all cameras.-- Args:- points3d: Shape (N, 3) - 3D world coordinates-- Returns:- Dictionary mapping camera_id to (N, 2) 2D pixel coordinates- """- points2d_by_camera: dict[str, np.ndarray] = {}-- for camera_id, camera in self.camera_calibrations.items():- points2d = camera.project_3d_to_2d(points3d)-- # Add noise if specified- if self.noise_std > 0:- noise = np.random.normal(0, self.noise_std, points2d.shape)- points2d = points2d + noise-- points2d_by_camera[camera_id] = points2d-- return points2d_by_camera-- def create_toml_file(self, output_path: Path) -> None:- """Save calibration data to TOML file."""- toml_data: dict = {}-- for camera_id, camera in self.camera_calibrations.items():- toml_data[camera_id] = {- "size": list(camera.image_size),- "matrix": {"matrix": camera.matrix.matrix.tolist()},- "distortions": {"coefficients": camera.distortion.coefficients.tolist()},- "rotation": camera.rotation_vector.tolist(),- "translation": camera.translation.tolist(),- }-- with open(output_path, "w") as f:- toml.dump(toml_data, f)---def synthetic_setup_2_cameras() -> SyntheticCameraSetup:- """Create a simple 2-camera stereo setup."""- return SyntheticCameraSetup(num_cameras=2, baseline=0.5, noise_std=0.0)---def synthetic_setup_4_cameras() -> SyntheticCameraSetup:- """Create a 4-camera setup."""- return SyntheticCameraSetup(num_cameras=4, baseline=0.3, noise_std=0.0)---def synthetic_setup_with_noise() -> SyntheticCameraSetup:- """Create a 3-camera setup with realistic noise."""- return SyntheticCameraSetup(num_cameras=3, baseline=0.4, noise_std=0.5)---def random_3d_points() -> np.ndarray:- """Generate random 3D points in front of cameras."""- np.random.seed(42)- num_points = 20-- # Generate points in a reasonable volume IN FRONT of cameras (positive Z)- # X and Y spread, Z from 1m to 5m in front- points3d = np.random.uniform(- low=[-0.5, -0.5, 1.0], high=[0.5, 0.5, 5.0], size=(num_points, 3)- )-- return points3d.astype(np.float64)---class TestPointTriangulator:- """Test suite for PointTriangulator."""-- def test_create_from_dict(self, synthetic_setup_2_cameras: SyntheticCameraSetup) -> None:- """Test creating triangulator from calibration dict."""- triangulator = PointTriangulator(- camera_calibrations=synthetic_setup_2_cameras.camera_calibrations- )-- assert triangulator.num_cameras == 2- assert len(triangulator.camera_names) == 2- assert triangulator.projection_matrices.shape == (2, 3, 4)-- def test_create_from_toml(self, synthetic_setup_4_cameras: SyntheticCameraSetup) -> None:- """Test loading triangulator from TOML file."""- with tempfile.TemporaryDirectory() as tmpdir:- toml_path = Path(tmpdir) / "calibration.toml"- synthetic_setup_4_cameras.create_toml_file(toml_path)-- triangulator = PointTriangulator.from_toml(toml_path)-- assert triangulator.num_cameras == 4- assert len(triangulator.camera_names) == 4- assert all(- name in triangulator.camera_calibrations- for name in [f"cam_{i:02d}" for i in range(4)]- )-- def test_triangulation_perfect_conditions(- self, synthetic_setup_2_cameras: SyntheticCameraSetup, random_3d_points: np.ndarray- ) -> None:- """Test triangulation with perfect synthetic data (no noise)."""- triangulator = PointTriangulator(- camera_calibrations=synthetic_setup_2_cameras.camera_calibrations- )-- # Project 3D points to 2D- points2d_by_camera = synthetic_setup_2_cameras.project_points(random_3d_points)-- # Stack into (M, N, 2) format- points2d = np.stack(- [points2d_by_camera[cam_id] for cam_id in triangulator.camera_names], axis=1- )-- # Triangulate- triangulated_3d, errors = triangulator.triangulate_points(- points2d=points2d, undistort_points=False, compute_reprojection_error=True- )-- # Check shape- assert triangulated_3d.shape == random_3d_points.shape- assert errors is not None- assert errors.shape == (random_3d_points.shape[0],)-- # Check accuracy - should be very accurate with no noise- max_error = np.max(np.linalg.norm(triangulated_3d - random_3d_points, axis=1))- assert max_error < 0.01, f"Max reconstruction error: {max_error:.6f}m"-- # Check reprojection errors are small- assert np.max(errors) < 1.0, f"Max reprojection error: {np.max(errors):.3f} pixels"-- def test_triangulation_multiple_cameras(- self, synthetic_setup_4_cameras: SyntheticCameraSetup, random_3d_points: np.ndarray- ) -> None:- """Test triangulation with 4 cameras improves accuracy."""- triangulator = PointTriangulator(- camera_calibrations=synthetic_setup_4_cameras.camera_calibrations- )-- points2d_by_camera = synthetic_setup_4_cameras.project_points(random_3d_points)-- points2d = np.stack(- [points2d_by_camera[cam_id] for cam_id in triangulator.camera_names], axis=1- )-- triangulated_3d, errors = triangulator.triangulate_points(- points2d=points2d, undistort_points=False, compute_reprojection_error=True- )-- # More cameras should give better accuracy- max_error = np.max(np.linalg.norm(triangulated_3d - random_3d_points, axis=1))- assert max_error < 0.005, f"Max reconstruction error: {max_error:.6f}m"-- mean_reprojection_error = np.mean(errors)- assert mean_reprojection_error < 0.5, f"Mean reprojection error: {mean_reprojection_error:.3f} pixels"-- def test_triangulation_with_noise(- self, synthetic_setup_with_noise: SyntheticCameraSetup, random_3d_points: np.ndarray- ) -> None:- """Test triangulation with realistic pixel noise."""- triangulator = PointTriangulator(- camera_calibrations=synthetic_setup_with_noise.camera_calibrations- )-- points2d_by_camera = synthetic_setup_with_noise.project_points(random_3d_points)-- points2d = np.stack(- [points2d_by_camera[cam_id] for cam_id in triangulator.camera_names], axis=1- )-- triangulated_3d, errors = triangulator.triangulate_points(- points2d=points2d, undistort_points=False, compute_reprojection_error=True- )-- # With noise, accuracy will be worse but still reasonable- max_error = np.max(np.linalg.norm(triangulated_3d - random_3d_points, axis=1))- assert max_error < 0.1, f"Max reconstruction error with noise: {max_error:.6f}m"-- # Reprojection errors should reflect the added noise- mean_reprojection_error = np.mean(errors)- assert mean_reprojection_error > 0.3, "Reprojection error should reflect added noise"- assert mean_reprojection_error < 2.0, f"Mean reprojection error too high: {mean_reprojection_error:.3f} pixels"-- def test_triangulate_dict_api_manual_debug(- self, synthetic_setup_2_cameras: SyntheticCameraSetup- ) -> None:- """Manually debug the dict triangulation to isolate the issue."""- triangulator = PointTriangulator(- camera_calibrations=synthetic_setup_2_cameras.camera_calibrations- )-- # Single test point - NOT at origin to avoid degenerate case- test_point_3d = np.array([[0.1, 0.2, 1.0]])-- # Project using each camera- points2d_list: list[np.ndarray] = []- for cam_id in triangulator.camera_names:- camera = triangulator.camera_calibrations[cam_id]- point_2d = camera.project_3d_to_2d(test_point_3d)- points2d_list.append(point_2d)- print(f"Camera {cam_id} projects {test_point_3d[0]} to {point_2d[0]}")-- # Test array API- points2d_array = np.stack(points2d_list, axis=1)- print(f"\nArray API input shape: {points2d_array.shape}")- print(f"Array API input:\n{points2d_array}")-- result_array, _ = triangulator.triangulate_points(points2d=points2d_array)- print(f"Array API result: {result_array[0]}")- print(f"Array API error: {np.linalg.norm(result_array[0] - test_point_3d[0]):.6f}m")-- # Now manually do what dict API does- points2d_by_camera_dict: dict[str, dict[str, tuple[float, float]]] = {}- for idx, cam_id in enumerate(triangulator.camera_names):- points2d_by_camera_dict[cam_id] = {- "test_point": (float(points2d_list[idx][0, 0]), float(points2d_list[idx][0, 1]))- }-- print(f"\nDict API input: {points2d_by_camera_dict}")-- result_dict = triangulator.triangulate_dict(- points2d_by_camera=points2d_by_camera_dict,- min_cameras=2- )-- print(f"Dict API result: {result_dict['test_point']}")-- reconstructed = np.array(result_dict['test_point'])- assert not np.any(np.isnan(reconstructed)), f"Dict API returned NaN: {reconstructed}"-- error = np.linalg.norm(reconstructed - test_point_3d[0])- assert error < 0.01, f"Dict API error: {error:.6f}m"-- def test_triangulate_dict_api(- self, synthetic_setup_2_cameras: SyntheticCameraSetup- ) -> None:- """Test dictionary-based triangulation API."""- triangulator = PointTriangulator(- camera_calibrations=synthetic_setup_2_cameras.camera_calibrations- )-- # Create test points with names - all in front of cameras (positive Z)- test_points_3d: dict[str, np.ndarray] = {- "point_A": np.array([0.0, 0.0, 2.0]),- "point_B": np.array([0.3, 0.2, 3.0]),- "point_C": np.array([-0.2, -0.1, 2.5]),- }-- # First verify that the array-based API works with the same points- points2d_by_camera_for_array: dict[str, np.ndarray] = {}- for camera_id in triangulator.camera_names:- camera = synthetic_setup_2_cameras.camera_calibrations[camera_id]- points3d_array = np.array([test_points_3d[name] for name in test_points_3d.keys()])- points2d_array = camera.project_3d_to_2d(points3d_array)- points2d_by_camera_for_array[camera_id] = points2d_array-- # Stack for array API- points2d_stacked = np.stack(- [points2d_by_camera_for_array[cam_id] for cam_id in triangulator.camera_names],- axis=1- )-- # Verify array API works- array_result, _ = triangulator.triangulate_points(points2d=points2d_stacked)- assert not np.any(np.isnan(array_result)), "Array API should not return NaN"-- # Now test dict API with the same data- # IMPORTANT: Maintain consistent point name order across all cameras- point_names_ordered = list(test_points_3d.keys())- points2d_by_camera: dict[str, dict[str, tuple[float, float]]] = {}-- for camera_id in triangulator.camera_names:- points2d_by_camera[camera_id] = {}- for idx, point_name in enumerate(point_names_ordered):- point_2d = points2d_by_camera_for_array[camera_id][idx]- points2d_by_camera[camera_id][point_name] = (float(point_2d[0]), float(point_2d[1]))-- # Triangulate using dict API- results = triangulator.triangulate_dict(- points2d_by_camera=points2d_by_camera,- min_cameras=2,- compute_reprojection_error=False,- )-- # Verify results- assert len(results) == 3, f"Expected 3 results, got {len(results)}"-- for point_idx, (point_name, point_3d_original) in enumerate(test_points_3d.items()):- assert point_name in results, f"Point {point_name} not in results"- reconstructed = np.array(results[point_name])-- # Check that we got valid (non-NaN) results- if np.any(np.isnan(reconstructed)):- print(f"\nDEBUG INFO for {point_name}:")- print(f" Reconstructed (dict API): {reconstructed}")- print(f" Expected (array API): {array_result[point_idx]}")- print(f" Original 3D: {point_3d_original}")- print(f" 2D observations:")- for cam_id in triangulator.camera_names:- print(f" {cam_id}: {points2d_by_camera[cam_id][point_name]}")- print(f" Camera names order: {triangulator.camera_names}")- print(f" Points2d dict keys: {list(points2d_by_camera.keys())}")-- assert not np.any(np.isnan(reconstructed)), (- f"Point {point_name} returned NaN: {reconstructed}\n"- f"Array API gave: {array_result[point_idx]}"- )-- error = np.linalg.norm(reconstructed - point_3d_original)- assert error < 0.01, f"Point {point_name} reconstruction error: {error:.6f}m"-- def test_triangulate_dict_with_reprojection_error(- self, synthetic_setup_2_cameras: SyntheticCameraSetup- ) -> None:- """Test dict API with reprojection error computation."""- triangulator = PointTriangulator(- camera_calibrations=synthetic_setup_2_cameras.camera_calibrations- )-- test_point_3d = np.array([0.1, -0.05, 2.5])-- points2d_by_camera: dict[str, dict[str, tuple[float, float]]] = {}- for camera_id in triangulator.camera_names:- camera = synthetic_setup_2_cameras.camera_calibrations[camera_id]- point_2d = camera.project_3d_to_2d(test_point_3d.reshape(1, 3))[0]- points2d_by_camera[camera_id] = {- "test_point": (float(point_2d[0]), float(point_2d[1]))- }-- results = triangulator.triangulate_dict(- points2d_by_camera=points2d_by_camera,- min_cameras=2,- compute_reprojection_error=True,- )-- assert "test_point" in results- assert isinstance(results["test_point"], dict)- assert "point" in results["test_point"]- assert "error" in results["test_point"]-- reconstructed = np.array(results["test_point"]["point"])- error_3d = np.linalg.norm(reconstructed - test_point_3d)- assert error_3d < 0.01-- reprojection_error = results["test_point"]["error"]- assert reprojection_error < 1.0-- def test_triangulate_dict_missing_observations(- self, synthetic_setup_4_cameras: SyntheticCameraSetup- ) -> None:- """Test dict API when some cameras don't observe all points."""- triangulator = PointTriangulator(- camera_calibrations=synthetic_setup_4_cameras.camera_calibrations- )-- test_point_3d = np.array([0.0, 0.0, 2.0])-- # Only 3 out of 4 cameras observe the point- cameras_to_use = list(triangulator.camera_names)[:3]-- points2d_by_camera: dict[str, dict[str, tuple[float, float]]] = {}- for camera_id in cameras_to_use:- camera = synthetic_setup_4_cameras.camera_calibrations[camera_id]- point_2d = camera.project_3d_to_2d(test_point_3d.reshape(1, 3))[0]- points2d_by_camera[camera_id] = {- "visible_point": (float(point_2d[0]), float(point_2d[1]))- }-- results = triangulator.triangulate_dict(- points2d_by_camera=points2d_by_camera, min_cameras=2- )-- assert "visible_point" in results- reconstructed = np.array(results["visible_point"])- error = np.linalg.norm(reconstructed - test_point_3d)- assert error < 0.01-- def test_triangulate_dict_insufficient_cameras(- self, synthetic_setup_4_cameras: SyntheticCameraSetup- ) -> None:- """Test dict API when point is only visible in one camera (should return NaN)."""- triangulator = PointTriangulator(- camera_calibrations=synthetic_setup_4_cameras.camera_calibrations- )-- test_point_3d = np.array([0.0, 0.0, 3.0])-- # Only 1 camera observes the point (insufficient)- camera_id = triangulator.camera_names[0]- camera = synthetic_setup_4_cameras.camera_calibrations[camera_id]- point_2d = camera.project_3d_to_2d(test_point_3d.reshape(1, 3))[0]-- points2d_by_camera: dict[str, dict[str, tuple[float, float]]] = {- camera_id: {"insufficient_point": (float(point_2d[0]), float(point_2d[1]))}- }-- results = triangulator.triangulate_dict(- points2d_by_camera=points2d_by_camera, min_cameras=2- )-- assert "insufficient_point" in results- result_tuple = results["insufficient_point"]- assert all(np.isnan(result_tuple))-- def test_triangulation_validates_input_shape(- self, synthetic_setup_2_cameras: SyntheticCameraSetup- ) -> None:- """Test that triangulation validates input array shapes."""- triangulator = PointTriangulator(- camera_calibrations=synthetic_setup_2_cameras.camera_calibrations- )-- # Wrong number of cameras- wrong_camera_count = np.random.rand(10, 3, 2) # 3 cameras instead of 2- with pytest.raises(ValueError, match="cameras but triangulator"):- triangulator.triangulate_points(points2d=wrong_camera_count)-- # Wrong last dimension- wrong_dim = np.random.rand(10, 2, 3) # Last dim should be 2, not 3- with pytest.raises(ValueError, match="must have shape"):- triangulator.triangulate_points(points2d=wrong_dim)-- def test_undistort_points_returns_normalized_coordinates(- self, synthetic_setup_2_cameras: SyntheticCameraSetup, random_3d_points: np.ndarray- ) -> None:- """- Test that undistort_points flag works correctly.-- NOTE: When undistort_points=True, cv2.undistortPoints returns NORMALIZED- camera coordinates (not pixel coordinates), so the triangulation results- will differ from using pixel coordinates directly.- """- triangulator = PointTriangulator(- camera_calibrations=synthetic_setup_2_cameras.camera_calibrations- )-- points2d_by_camera = synthetic_setup_2_cameras.project_points(random_3d_points)- points2d = np.stack(- [points2d_by_camera[cam_id] for cam_id in triangulator.camera_names], axis=1- )-- # Triangulate with pixel coordinates (standard approach)- triangulated_no_undistort, _ = triangulator.triangulate_points(- points2d=points2d, undistort_points=False- )-- # Verify this gives accurate results- max_error = np.max(np.linalg.norm(triangulated_no_undistort - random_3d_points, axis=1))- assert max_error < 0.01, "Standard triangulation should be accurate"-- # The undistort_points flag changes coordinate system, so we just verify it runs- # without errors (actual correctness depends on using appropriate projection matrices)- triangulated_with_undistort, _ = triangulator.triangulate_points(- points2d=points2d, undistort_points=True- )-- # Just verify we got valid output- assert triangulated_with_undistort.shape == random_3d_points.shape- assert not np.any(np.isnan(triangulated_with_undistort))-- def test_reprojection_error_computation(- self, synthetic_setup_2_cameras: SyntheticCameraSetup, random_3d_points: np.ndarray- ) -> None:- """Test that reprojection error computation is accurate."""- triangulator = PointTriangulator(- camera_calibrations=synthetic_setup_2_cameras.camera_calibrations- )-- points2d_by_camera = synthetic_setup_2_cameras.project_points(random_3d_points)- points2d = np.stack(- [points2d_by_camera[cam_id] for cam_id in triangulator.camera_names], axis=1- )-- triangulated_3d, errors = triangulator.triangulate_points(- points2d=points2d, compute_reprojection_error=True- )-- # Manually compute reprojection for first point to verify- point_3d = triangulated_3d[0]- manual_errors: list[float] = []-- for camera_id, camera in triangulator.camera_calibrations.items():- projected = camera.project_3d_to_2d(point_3d.reshape(1, 3))[0]- cam_idx = triangulator.camera_names.index(camera_id)- original = points2d[0, cam_idx]- error = np.linalg.norm(projected - original)- manual_errors.append(error)-- manual_mean_error = np.mean(manual_errors)-- # Should match computed error for first point- assert np.abs(errors[0] - manual_mean_error) < 0.01-- def test_empty_triangulator_raises_error(self) -> None:- """Test that creating triangulator with no cameras raises error."""- with pytest.raises(ValueError, match="cannot be empty"):- PointTriangulator(camera_calibrations={})-- def test_camera_calibration_data_world_coordinates(- self, synthetic_setup_2_cameras: SyntheticCameraSetup- ) -> None:- """Test that world_position and world_orientation are computed correctly."""- camera = list(synthetic_setup_2_cameras.camera_calibrations.values())[0]-- # World position should be non-zero (camera is not at origin)- assert np.linalg.norm(camera.world_position) > 0.1-- # World orientation should be orthonormal- assert np.allclose(- camera.world_orientation @ camera.world_orientation.T, np.eye(3), atol=1e-6- )-- def test_projection_and_unprojection_consistency(- self, synthetic_setup_2_cameras: SyntheticCameraSetup- ) -> None:- """Test that project_3d_to_2d and triangulation are consistent."""- triangulator = PointTriangulator(- camera_calibrations=synthetic_setup_2_cameras.camera_calibrations- )-- # Single test point in front of cameras- original_3d = np.array([[0.05, 0.1, 2.0]])-- # Project to 2D- points2d_list: list[np.ndarray] = []- for camera in triangulator.camera_calibrations.values():- point_2d = camera.project_3d_to_2d(original_3d)- points2d_list.append(point_2d)-- points2d = np.stack(points2d_list, axis=1)-- # Triangulate back- reconstructed_3d, _ = triangulator.triangulate_points(points2d=points2d)-- # Should match original- error = np.linalg.norm(reconstructed_3d[0] - original_3d[0])- assert error < 0.001, f"Round-trip error: {error:.6f}m"---class TestCameraCalibrationData:- """Test suite for CameraCalibrationData class."""-- def test_from_dict_with_image_size_key(self) -> None:- """Test loading from dict with 'image_size' key."""- data = {- "image_size": [1920, 1080],- "matrix": {"matrix": [[1000.0, 0.0, 960.0], [0.0, 1000.0, 540.0], [0.0, 0.0, 1.0]]},- "distortions": {"coefficients": [0.0, 0.0, 0.0, 0.0, 0.0]},- "rotation": [0.0, 0.0, 0.0],- "translation": [0.0, 0.0, 0.0],- }-- camera = CameraCalibrationData.from_dict(camera_id="test_cam", data=data)-- assert camera.name == "test_cam"- assert camera.image_size == (1920, 1080)-- def test_from_dict_with_size_key(self) -> None:- """Test loading from dict with 'size' key (legacy)."""- data = {- "size": [1280, 720],- "matrix": {"matrix": [[800.0, 0.0, 640.0], [0.0, 800.0, 360.0], [0.0, 0.0, 1.0]]},- "distortions": {"coefficients": [0.0, 0.0, 0.0, 0.0, 0.0]},- "rotation": [0.0, 0.0, 0.0],- "translation": [0.0, 0.0, 0.0],- }-- camera = CameraCalibrationData.from_dict(camera_id="legacy_cam", data=data)-- assert camera.image_size == (1280, 720)-- def test_from_dict_missing_size_raises_error(self) -> None:- """Test that missing size key raises error."""- data = {- "matrix": {"matrix": [[1000.0, 0.0, 960.0], [0.0, 1000.0, 540.0], [0.0, 0.0, 1.0]]},- "distortions": {"coefficients": [0.0, 0.0, 0.0, 0.0, 0.0]},- "rotation": [0.0, 0.0, 0.0],- "translation": [0.0, 0.0, 0.0],- }-- with pytest.raises(KeyError, match="image_size"):- CameraCalibrationData.from_dict(camera_id="bad_cam", data=data)-- def test_projection_matrix_shape(- self, synthetic_setup_2_cameras: SyntheticCameraSetup- ) -> None:- """Test that projection matrix has correct shape."""- camera = list(synthetic_setup_2_cameras.camera_calibrations.values())[0]-- assert camera.projection_matrix.shape == (3, 4)- assert camera.extrinsics_matrix.shape == (3, 4)-- def test_undistort_points_shape_preservation(- self, synthetic_setup_2_cameras: SyntheticCameraSetup- ) -> None:- """Test that undistort_points preserves input shape."""- camera = list(synthetic_setup_2_cameras.camera_calibrations.values())[0]-- # Test with different input shapes- points_2d_flat = np.random.rand(10, 2) * 1000- points_2d_opencv = np.random.rand(10, 1, 2) * 1000-- undistorted_flat = camera.undistort_points(points_2d_flat)- undistorted_opencv = camera.undistort_points(points_2d_opencv)-- assert undistorted_flat.shape == (10, 2)- assert undistorted_opencv.shape == (10, 1, 2)---if __name__ == "__main__":- pytest.main([__file__])diff --git a/freemocap/tests/test_websocket_settings_protocol.py b/freemocap/tests/test_websocket_settings_protocol.pynew file mode 100644index 00000000..9d09f8a5--- /dev/null+++ b/freemocap/tests/test_websocket_settings_protocol.py@@ -0,0 +1,344 @@+"""+WebSocket settings protocol tests: verify handle_settings_message routing,+patch application, pipeline sync, and the settings_state_relay push loop.+"""+import asyncio+import json+import threading+from copy import deepcopy+from typing import Any+from unittest.mock import AsyncMock, MagicMock++import pytest++from freemocap.app.settings import SettingsManager+from freemocap.app.settings_protocol import (+ _sync_patch_to_app,+ handle_settings_message,+ settings_state_relay,+)+from freemocap.core.pipeline.pipeline_configs import (+ CalibrationPipelineConfig,+ MocapPipelineConfig,+)+++from starlette.websockets import WebSocketState+++# ---------------------------------------------------------------------------+# Mock helpers+# ---------------------------------------------------------------------------+++class MockPipeline:+ def __init__(self) -> None:+ self.config = MagicMock()+ self.config.calibration_config = CalibrationPipelineConfig()+ self.config.mocap_config = MocapPipelineConfig.default_realtime()+ self.update_config_calls: list[Any] = []++ def update_config(self, new_config: Any) -> None:+ self.update_config_calls.append(deepcopy(new_config))+++class MockPipelineManager:+ def __init__(self) -> None:+ self.lock = threading.Lock()+ self.pipeline = MockPipeline()+ self.pipelines: dict[str, MockPipeline] = {"test": self.pipeline}+++class MockApp:+ def __init__(self) -> None:+ self.settings_manager = SettingsManager()+ self.realtime_pipeline_manager = MockPipelineManager()+++class FakeWebSocket:+ """Minimal WebSocket mock that records sent messages.+ Uses the real WebSocketState enum so comparisons in the relay work."""++ def __init__(self) -> None:+ self.client_state = WebSocketState.CONNECTED+ self.sent_json: list[dict[str, Any]] = []++ async def send_json(self, data: dict[str, Any]) -> None:+ self.sent_json.append(data)+++# ---------------------------------------------------------------------------+# handle_settings_message+# ---------------------------------------------------------------------------+++class TestHandleSettingsMessage:++ def test_patch_applies_to_settings_manager(self) -> None:+ app = MockApp()+ manager = app.settings_manager+ handle_settings_message(+ data={+ "message_type": "settings/patch",+ "patch": {"calibration": {"is_recording": True}},+ },+ settings_manager=manager,+ app=app,+ )+ assert manager.settings.calibration.is_recording is True++ def test_patch_bumps_version(self) -> None:+ app = MockApp()+ manager = app.settings_manager+ assert manager.version == 0+ handle_settings_message(+ data={+ "message_type": "settings/patch",+ "patch": {"calibration": {"is_recording": True}},+ },+ settings_manager=manager,+ app=app,+ )+ assert manager.version >= 1++ def test_patch_with_calibration_config_syncs_to_pipelines(self) -> None:+ app = MockApp()+ handle_settings_message(+ data={+ "message_type": "settings/patch",+ "patch": {+ "calibration": {+ "config": {"charuco_board_x_squares": 9},+ },+ },+ },+ settings_manager=app.settings_manager,+ app=app,+ )+ pipeline = app.realtime_pipeline_manager.pipeline+ assert len(pipeline.update_config_calls) == 1++ def test_patch_with_mocap_config_syncs_to_pipelines(self) -> None:+ app = MockApp()+ handle_settings_message(+ data={+ "message_type": "settings/patch",+ "patch": {+ "mocap": {+ "config": {+ "skeleton_filter": {"beta": 0.99},+ },+ },+ },+ },+ settings_manager=app.settings_manager,+ app=app,+ )+ pipeline = app.realtime_pipeline_manager.pipeline+ assert len(pipeline.update_config_calls) == 1++ def test_patch_without_config_does_not_sync_pipelines(self) -> None:+ """Patching only status fields should not trigger pipeline sync."""+ app = MockApp()+ handle_settings_message(+ data={+ "message_type": "settings/patch",+ "patch": {"calibration": {"is_recording": True}},+ },+ settings_manager=app.settings_manager,+ app=app,+ )+ pipeline = app.realtime_pipeline_manager.pipeline+ assert len(pipeline.update_config_calls) == 0++ def test_request_triggers_notify(self) -> None:+ app = MockApp()+ manager = app.settings_manager+ initial_version = manager.version+ handle_settings_message(+ data={"message_type": "settings/request"},+ settings_manager=manager,+ app=app,+ )+ assert manager.version == initial_version + 1++ def test_unknown_type_raises(self) -> None:+ app = MockApp()+ with pytest.raises(ValueError, match="Unknown settings message_type"):+ handle_settings_message(+ data={"message_type": "settings/bogus"},+ settings_manager=app.settings_manager,+ app=app,+ )++ def test_patch_missing_patch_field_raises(self) -> None:+ app = MockApp()+ with pytest.raises(ValueError, match="no 'patch' field"):+ handle_settings_message(+ data={"message_type": "settings/patch"},+ settings_manager=app.settings_manager,+ app=app,+ )+++# ---------------------------------------------------------------------------+# _sync_patch_to_app+# ---------------------------------------------------------------------------+++class TestSyncPatchToApp:++ def test_calibration_config_patch_syncs(self) -> None:+ app = MockApp()+ # First apply the patch to the settings manager so it has the new config+ app.settings_manager.apply_patch({+ "calibration": {"config": {"charuco_board_x_squares": 11}},+ })+ _sync_patch_to_app(+ patch={"calibration": {"config": {"charuco_board_x_squares": 11}}},+ settings_manager=app.settings_manager,+ app=app,+ )+ pipeline = app.realtime_pipeline_manager.pipeline+ assert len(pipeline.update_config_calls) == 1++ def test_mocap_config_patch_syncs(self) -> None:+ app = MockApp()+ app.settings_manager.apply_patch({+ "mocap": {"config": {"skeleton_filter": {"beta": 0.1}}},+ })+ _sync_patch_to_app(+ patch={"mocap": {"config": {"skeleton_filter": {"beta": 0.1}}}},+ settings_manager=app.settings_manager,+ app=app,+ )+ pipeline = app.realtime_pipeline_manager.pipeline+ assert len(pipeline.update_config_calls) == 1++ def test_non_config_patch_does_not_sync(self) -> None:+ app = MockApp()+ _sync_patch_to_app(+ patch={"calibration": {"is_recording": True}},+ settings_manager=app.settings_manager,+ app=app,+ )+ pipeline = app.realtime_pipeline_manager.pipeline+ assert len(pipeline.update_config_calls) == 0++ def test_unrelated_patch_does_not_sync(self) -> None:+ app = MockApp()+ _sync_patch_to_app(+ patch={"cameras": {}},+ settings_manager=app.settings_manager,+ app=app,+ )+ pipeline = app.realtime_pipeline_manager.pipeline+ assert len(pipeline.update_config_calls) == 0+++# ---------------------------------------------------------------------------+# settings_state_relay+# ---------------------------------------------------------------------------+++class TestSettingsStateRelay:++ @pytest.mark.asyncio+ async def test_sends_initial_state_on_startup(self) -> None:+ manager = SettingsManager()+ ws = FakeWebSocket()+ stop = False++ async def run_relay() -> None:+ await settings_state_relay(+ websocket=ws,+ settings_manager=manager,+ should_continue=lambda: not stop,+ )++ task = asyncio.create_task(run_relay())+ await asyncio.sleep(0.05)+ stop = True+ manager.notify_changed() # Wake the relay so it exits+ await asyncio.sleep(0.05)+ task.cancel()+ try:+ await task+ except asyncio.CancelledError:+ pass++ assert len(ws.sent_json) >= 1+ first_msg = ws.sent_json[0]+ assert first_msg["message_type"] == "settings/state"+ assert "settings" in first_msg+ assert "version" in first_msg++ @pytest.mark.asyncio+ async def test_sends_update_on_change(self) -> None:+ manager = SettingsManager()+ ws = FakeWebSocket()+ stop = False++ async def run_relay() -> None:+ await settings_state_relay(+ websocket=ws,+ settings_manager=manager,+ should_continue=lambda: not stop,+ )++ task = asyncio.create_task(run_relay())+ await asyncio.sleep(0.05)++ # Trigger a change+ manager.apply_patch({"calibration": {"is_recording": True}})+ await asyncio.sleep(0.05)++ stop = True+ manager.notify_changed() # Wake relay to exit+ await asyncio.sleep(0.05)+ task.cancel()+ try:+ await task+ except asyncio.CancelledError:+ pass++ # Should have at least 2 messages: initial + one change+ assert len(ws.sent_json) >= 2+ last_msg = ws.sent_json[-1]+ assert last_msg["message_type"] == "settings/state"+ assert last_msg["version"] >= 1++ @pytest.mark.asyncio+ async def test_version_increases_monotonically(self) -> None:+ manager = SettingsManager()+ ws = FakeWebSocket()+ stop = False++ async def run_relay() -> None:+ await settings_state_relay(+ websocket=ws,+ settings_manager=manager,+ should_continue=lambda: not stop,+ )++ task = asyncio.create_task(run_relay())+ await asyncio.sleep(0.05)++ for i in range(3):+ manager.apply_patch({"calibration": {"recording_progress": float(i * 10)}})+ await asyncio.sleep(0.05)++ stop = True+ manager.notify_changed()+ await asyncio.sleep(0.05)+ task.cancel()+ try:+ await task+ except asyncio.CancelledError:+ pass++ versions = [msg["version"] for msg in ws.sent_json]+ for i in range(1, len(versions)):+ assert versions[i] >= versions[i - 1], (+ f"Version went backwards: {versions}"+ )diff --git a/freemocap/utilities/check_main_processs_heartbeat.py b/freemocap/utilities/check_main_processs_heartbeat.pyindex 18c89988..34f6b535 100644--- a/freemocap/utilities/check_main_processs_heartbeat.py+++ b/freemocap/utilities/check_main_processs_heartbeat.py@@ -1,9 +1,8 @@+import loggingimport multiprocessingimport osimport signalimport time--import loggingfrom typing import Finallogger = logging.getLogger(__name__)diff --git a/freemocap/utilities/extract_camera_id_from_video_path.py b/freemocap/utilities/extract_camera_id_from_video_path.pyindex 98c2c903..d8ed7b16 100644--- a/freemocap/utilities/extract_camera_id_from_video_path.py+++ b/freemocap/utilities/extract_camera_id_from_video_path.py@@ -1,10 +1,6 @@import re-from pathlib import Path--from pydantic import BaseModel, ConfigDict, model_validatorfrom freemocap.core.pipeline.posthoc_pipelines.video_helper import VideoHelper, VideoMetadata-from freemocap.core.types.type_overloads import VideoIdStringdef extract_camera_id(filename: str) -> str | None:diff --git a/noxfile.py b/noxfile.pyindex f9ca1f38..96b2fb80 100644--- a/noxfile.py+++ b/noxfile.py@@ -1,41 +1,70 @@import noxfrom nox.sessions import Session+# Project requires Python >=3.11+PYTHON_VERSIONS = ["3.11", "3.12"][email protected](python=["3.9", "3.10", "3.11", "3.12"])-def test(session: Session):- """Run the full test suite on python versions 3.9, 3.10, 3.11, and 3.12."""- session.install("-e", ".")- session.run("pytest", "freemocap/tests")[email protected](python=PYTHON_VERSIONS)+def test(session: Session) -> None:+ """Run the full backend test suite."""+ session.install("-e", ".[dev]")+ session.run("pytest", "freemocap/tests", "-v")[email protected](python=["3.9", "3.10"])-def test_9_10(session: Session):- """Run the full test suite on python versions 3.9 and 3.10."""- session.install("-e", ".")- session.run("pytest", "freemocap/tests")[email protected](python="3.12")+def test_sync(session: Session) -> None:+ """Run only the frontend/backend sync tests (schema, settings, HTTP, WebSocket, E2E)."""+ session.install("-e", ".[dev]")+ session.run(+ "pytest",+ "freemocap/tests/test_schema_contract.py",+ "freemocap/tests/test_settings_manager.py",+ "freemocap/tests/test_http_config_endpoints.py",+ "freemocap/tests/test_websocket_settings_protocol.py",+ "freemocap/tests/test_e2e_http_settings_sync.py",+ "freemocap/tests/test_e2e_websocket_settings_sync.py",+ "-v",+ )++[email protected](python="3.12")+def test_e2e(session: Session) -> None:+ """Run end-to-end integration tests (HTTP + WebSocket round-trip)."""+ session.install("-e", ".[dev]")+ session.run(+ "pytest",+ "freemocap/tests/test_e2e_http_settings_sync.py",+ "freemocap/tests/test_e2e_websocket_settings_sync.py",+ "-v",+ )[email protected](python=["3.11", "3.12"])-def test_11_12(session: Session):- """Run the full test suite on python versions 3.11 and 3.12."""- session.install("-e", ".")- session.run("pytest", "freemocap/tests")+[email protected](python=False)+def test_ui(session: Session) -> None:+ """Run the frontend vitest suite (no Python needed)."""+ with session.cd("freemocap-ui"):+ session.run("npm", "run", "test", external=True)@nox.session(python="3.12")-def coverage(session: Session):- """Run a coverage test on python 3.12."""- session.install("-e", ".", "pytest-cov")- session.run("pytest", "--cov=freemocap", "freemocap/tests")+def test_all(session: Session) -> None:+ """Run backend tests, then frontend tests — the full picture."""+ session.install("-e", ".[dev]")+ session.run("pytest", "freemocap/tests", "-v")+ with session.cd("freemocap-ui"):+ session.run("npm", "run", "test", external=True)@nox.session(python="3.12")-def lint(session: Session):- """Lint using Flake8"""- session.install(- "flake8",- "flake8-bandit",- "flake8-bugbear",- )- session.run("flake8")+def coverage(session: Session) -> None:+ """Run a coverage report on the backend tests."""+ session.install("-e", ".[dev]", "pytest-cov")+ session.run("pytest", "--cov=freemocap", "freemocap/tests", "-v")++[email protected](python="3.12")+def lint(session: Session) -> None:+ """Lint with ruff."""+ session.install("ruff")+ session.run("ruff", "check", "freemocap/")\ No newline at end of filediff --git a/pyproject.toml b/pyproject.tomlindex 5c8a18ac..e4af9a2a 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -16,18 +16,19 @@ dependencies = ["skelly-viewer","skellycam","skellyforge",- "skellytracker",+ "skellytracker[mediapipe]","pydantic>=2.10.4","numpydantic>=1.6.7",# "ltrt""scikit-learn>=1.7.2","pyceres>=2.5",+ "tomli-w>=1.2.0",][tool.uv.sources]-skellycam = { git = "https://github.com/freemocap/skellycam", branch = "jon/development" }-skellytracker = { git = "https://github.com/freemocap/skellytracker", branch = "jon/development" }-skellyforge = { git = "https://github.com/freemocap/skellyforge", branch = "jon/development" }+skellycam = { git = "https://github.com/freemocap/skellycam", branch = "development" }+skellytracker = { git = "https://github.com/freemocap/skellytracker", branch = "development"}+skellyforge = { git = "https://github.com/freemocap/skellyforge", branch = "development" }[project.scripts]freemocap = "freemocap.__main__:main"@@ -35,10 +36,6 @@ freemocap = "freemocap.__main__:main"py-modules = ["freemocap"][tool.uv]package = true-dev-dependencies = [-# "pydantic2zod>=0.1.1",- "bumpver",-][tool.bumpver]@@ -53,3 +50,134 @@ push = true#"pyproject.toml" = ['current_version = "{version}"', 'version = "{version}"']"freemocap/__init__.py" = ["{version}"]".github/workflows/*_installer.yml" = ['export PYAPP_PROJECT_VERSION={version}']+++++# =============================================================================+# Dev dependencies+# =============================================================================+# Install with: uv sync --group dev+# =============================================================================++[dependency-groups]+dev = [+ "bumpver",+ "pip-tools",+ "pytest>=8.4.0",+ "pytest-asyncio>=1.0.0",+ "httpx>=0.28.0",+ "nuitka>=2.7.7",+ "pyinstaller>=6.15.0",+ "ruff>=0.9.0",+ "poethepoet>=0.32.0",+]+++# =============================================================================+# Task runner (poethepoet)+# =============================================================================+# List all tasks: uv run poe --help+#+# Type-checking imports:+# uv run poe tc-check Preview which imports can move behind TYPE_CHECKING+# uv run poe tc-fix Move them automatically+# uv run poe tc Move them + run tests to verify nothing broke+#+# Linting:+# uv run poe lint Run all ruff lint rules (report only)+# uv run poe lint-fix Auto-fix all ruff lint violations+#+# Testing:+# uv run poe test Run pytest+#+# ---- Handling false positives ----+#+# Ruff is smart about isinstance/issubclass — it won't move imports that+# appear in those calls. But if ruff tries to move an import that IS used+# at runtime (e.g. passed to a registry, used in a TypeAdapter, or checked+# in a way ruff can't see), suppress it with a noqa comment on the import:+#+# from freemocap.core.pipeline.pipeline_configs import DetectorSpec # noqa: TC001+#+# The rule codes are:+# TC001 — stdlib import (e.g. pathlib.Path used in isinstance)+# TC002 — third-party import (e.g. numpy.ndarray used in isinstance)+# TC003 — first-party import (e.g. your own types used in isinstance)+#+# Common situations where you MUST keep an import at runtime (use noqa):+# - isinstance(x, SomeClass) / issubclass(x, SomeClass)+# (ruff usually catches these, but check if it doesn't)+# - TypeAdapter(SomeModel) or model_validate() with a type argument+# - Passing a class to a function that does runtime type inspection+# - Using a class as a dict key or in a set for type dispatch+# - Base classes (class Foo(SomeBase):) — ruff always catches these+#+# =============================================================================++[tool.poe.tasks]+tc-check = { cmd = "ruff check --select TC freemocap/", help = "Preview type-only imports that can move behind TYPE_CHECKING" }+tc-fix = { cmd = "ruff check --select TC --fix freemocap/", help = "Move type-only imports behind TYPE_CHECKING" }+tc = { sequence = ["tc-fix", "test"], help = "Move type-only imports + run tests to verify" }+lint = { cmd = "ruff check freemocap/", help = "Run all ruff lint rules" }+lint-fix = { cmd = "ruff check --fix freemocap/", help = "Auto-fix all ruff lint violations" }++# --- Testing ---+test = { cmd = "pytest freemocap/tests/ -v", help = "Run all backend tests" }+test-schema = { cmd = "pytest freemocap/tests/test_schema_contract.py -v", help = "Run schema contract tests (frontend/backend sync)" }+test-settings = { cmd = "pytest freemocap/tests/test_settings_manager.py -v", help = "Run SettingsManager unit tests" }+test-http = { cmd = "pytest freemocap/tests/test_http_config_endpoints.py -v", help = "Run HTTP endpoint integration tests" }+test-ws = { cmd = "pytest freemocap/tests/test_websocket_settings_protocol.py -v", help = "Run WebSocket protocol tests" }+test-e2e = { cmd = "pytest freemocap/tests/test_e2e_http_settings_sync.py freemocap/tests/test_e2e_websocket_settings_sync.py -v", help = "Run end-to-end integration tests (HTTP + WebSocket round-trip)" }+test-sync = { cmd = "pytest freemocap/tests/test_schema_contract.py freemocap/tests/test_settings_manager.py freemocap/tests/test_http_config_endpoints.py freemocap/tests/test_websocket_settings_protocol.py freemocap/tests/test_e2e_http_settings_sync.py freemocap/tests/test_e2e_websocket_settings_sync.py -v", help = "Run all frontend/backend sync tests" }+test-all = { sequence = ["test"], help = "Run all backend tests (run `npm test` in freemocap-ui/ separately for frontend)" }++[tool.poe.tasks.test-ui]+cmd = "npm run test"+cwd = "freemocap-ui"+help = "Run frontend tests — run `npm test` in freemocap-ui/ )"+++# =============================================================================+# Pytest config+# =============================================================================++[tool.pytest.ini_options]+asyncio_mode = "auto"+++# =============================================================================+# Ruff linter config+# =============================================================================+# TC rules move imports that are ONLY used in type annotations behind an+# `if TYPE_CHECKING:` block, so they don't execute at runtime. This makes+# multiprocessing child process spawns faster (fewer files to import).+#+# Ruff automatically detects and preserves imports used in:+# - isinstance() / issubclass() calls+# - Base classes+# - Default values and runtime expressions+# - Pydantic field types (via runtime-evaluated-base-classes below)+# - Dataclass field types (via runtime-evaluated-decorators below)+#+# If ruff incorrectly flags an import that IS needed at runtime,+# add # noqa: TC003 (or TC001/TC002) to that import line.+# =============================================================================++[tool.ruff.lint]+select = [+ "TC", # flake8-type-checking: move type-only imports behind TYPE_CHECKING+]++[tool.ruff.lint.flake8-type-checking]+# Pydantic evaluates field type annotations at runtime for validation/serialization.+# Imports used as field types on these base classes must NOT be moved behind+# TYPE_CHECKING or Pydantic will fail at class creation.+runtime-evaluated-base-classes = [+ "pydantic.BaseModel",+ "pydantic.BaseSettings",+]+runtime-evaluated-decorators = [+ "dataclasses.dataclass",+]+exempt-modules = ["typing", "typing_extensions"]\ No newline at end of filediff --git a/scripts/compare_calibrations.py b/scripts/compare_calibrations.pynew file mode 100644index 00000000..7556c231--- /dev/null+++ b/scripts/compare_calibrations.py@@ -0,0 +1,554 @@+"""Compare calibration results and assess calibration health.++Provides:+ - Per-calibration health report (board reconstruction accuracy, per-camera stats)+ - Side-by-side comparison of two CalibrationResult objects+"""++import logging++import numpy as np+from numpy.typing import NDArray+from pydantic import BaseModel, ConfigDict++from freemocap.core.calibration.shared.calibration_models import CharucoBoardDefinition, CameraModel, \+ CharucoCornersObservation, CalibrationResult++logger = logging.getLogger(__name__)+++# =============================================================================+# TRIANGULATION (shared utility)+# =============================================================================+++def _triangulate_point_dlt(+ pixel_observations: list[tuple[NDArray[np.float64], NDArray[np.float64]]],+) -> NDArray[np.float64] | None:+ """Triangulate a single 3D point from 2D observations via DLT.++ Args:+ pixel_observations: List of (pixel_xy, projection_matrix_3x4) tuples.++ Returns:+ (3,) 3D point, or None if degenerate.+ """+ n_views = len(pixel_observations)+ if n_views < 2:+ return None++ A = np.zeros((n_views * 2, 4), dtype=np.float64)+ for vi, (px, P) in enumerate(pixel_observations):+ x, y = px+ A[vi * 2] = x * P[2] - P[0]+ A[vi * 2 + 1] = y * P[2] - P[1]++ _, _, vh = np.linalg.svd(A, full_matrices=False)+ pt_h = vh[-1]+ if abs(pt_h[3]) < 1e-10:+ return None+ return pt_h[:3] / pt_h[3]+++# =============================================================================+# BOARD RECONSTRUCTION+# =============================================================================+++def _get_adjacent_corner_pairs(+ board: CharucoBoardDefinition,+) -> tuple[list[tuple[int, int]], list[tuple[int, int]]]:+ """Get horizontal and vertical adjacent corner index pairs.++ Returns:+ (horizontal_pairs, vertical_pairs) — each a list of (idx_a, idx_b).+ Expected distance for each pair is board.square_length_mm.+ """+ cols = board.squares_x - 1+ rows = board.squares_y - 1++ horizontal: list[tuple[int, int]] = []+ vertical: list[tuple[int, int]] = []++ for r in range(rows):+ for c in range(cols):+ idx = r * cols + c+ if c < cols - 1:+ horizontal.append((idx, idx + 1))+ if r < rows - 1:+ vertical.append((idx, idx + cols))++ return horizontal, vertical+++def _triangulate_board_frame(+ *,+ cameras: list[CameraModel],+ frame_observations: dict[str, CharucoCornersObservation],+ n_corners: int,+) -> NDArray[np.float64]:+ """Triangulate all board corners for a single frame.++ Returns:+ (n_corners, 3) array with NaN for corners that couldn't be triangulated.+ """+ cam_by_name = {cam.name: cam for cam in cameras}+ result = np.full((n_corners, 3), np.nan, dtype=np.float64)++ for corner_id in range(n_corners):+ observations: list[tuple[NDArray[np.float64], NDArray[np.float64]]] = []++ for cam_name, obs in frame_observations.items():+ cam = cam_by_name.get(cam_name)+ if cam is None:+ continue+ for c in obs.corners:+ if c.corner_id == corner_id:+ observations.append((c.pixel_xy, cam.projection_matrix))+ break++ pt = _triangulate_point_dlt(observations)+ if pt is not None:+ result[corner_id] = pt++ return result+++def _compute_board_distance_errors(+ *,+ cameras: list[CameraModel],+ board: CharucoBoardDefinition,+ all_observations: list[CharucoCornersObservation],+) -> NDArray[np.float64]:+ """Compute per-pair distance errors across all frames.++ For each frame, triangulates board corners and measures distances+ between adjacent corners. Returns the signed errors (measured - expected)+ for all valid pairs across all frames.+ """+ horizontal_pairs, vertical_pairs = _get_adjacent_corner_pairs(board=board)+ all_pairs = horizontal_pairs + vertical_pairs+ expected_distance = board.square_length_mm++ # Group observations by frame+ frame_groups: dict[int, dict[str, CharucoCornersObservation]] = {}+ for obs in all_observations:+ if obs.frame_index not in frame_groups:+ frame_groups[obs.frame_index] = {}+ frame_groups[obs.frame_index][obs.camera_name] = obs++ all_errors: list[float] = []++ for frame_idx in sorted(frame_groups.keys()):+ corners_3d = _triangulate_board_frame(+ cameras=cameras,+ frame_observations=frame_groups[frame_idx],+ n_corners=board.n_corners,+ )++ for idx_a, idx_b in all_pairs:+ pt_a = corners_3d[idx_a]+ pt_b = corners_3d[idx_b]+ if np.isnan(pt_a).any() or np.isnan(pt_b).any():+ continue+ measured = float(np.linalg.norm(pt_b - pt_a))+ all_errors.append(measured - expected_distance)++ return np.array(all_errors, dtype=np.float64)+++# =============================================================================+# CALIBRATION HEALTH REPORT+# =============================================================================+++class PerCameraHealth(BaseModel):+ """Health metrics for a single camera."""++ model_config = ConfigDict(extra="forbid")++ camera_name: str+ fx: float+ fy: float+ cx: float+ cy: float+ k1: float+ k2: float+ image_width: int+ image_height: int++ # Derived sanity checks+ focal_length_reasonable: bool+ principal_point_reasonable: bool+ fx_fy_ratio: float++ @property+ def summary(self) -> str:+ fl_flag = "✓" if self.focal_length_reasonable else "✗"+ pp_flag = "✓" if self.principal_point_reasonable else "✗"+ return (+ f" {self.camera_name}:\n"+ f" Focal length: fx={self.fx:.1f} fy={self.fy:.1f} "+ f"(fx/fy={self.fx_fy_ratio:.3f}) [{fl_flag}]\n"+ f" Principal point: cx={self.cx:.1f} cy={self.cy:.1f} "+ f"(image: {self.image_width}x{self.image_height}) [{pp_flag}]\n"+ f" Distortion: k1={self.k1:.4f} k2={self.k2:.4f}"+ )+++class BoardReconstructionHealth(BaseModel):+ """Board reconstruction accuracy — the ground-truth calibration quality metric.++ Triangulates charuco corners from the calibration and measures how+ well the inter-corner distances match the known board geometry.+ """++ model_config = ConfigDict(extra="forbid")++ n_distance_measurements: int+ expected_distance_mm: float++ # Signed errors (measured - expected) in mm+ mean_error_mm: float+ median_error_mm: float+ std_error_mm: float++ # Absolute errors in mm+ mean_abs_error_mm: float+ median_abs_error_mm: float+ max_abs_error_mm: float+ pct_within_1mm: float+ pct_within_5mm: float++ @property+ def summary(self) -> str:+ return (+ f" Board reconstruction ({self.n_distance_measurements} adjacent-corner distances, "+ f"expected={self.expected_distance_mm:.2f}mm):\n"+ f" Signed error: mean={self.mean_error_mm:+.3f}mm "+ f"median={self.median_error_mm:+.3f}mm std={self.std_error_mm:.3f}mm\n"+ f" Absolute error: mean={self.mean_abs_error_mm:.3f}mm "+ f"median={self.median_abs_error_mm:.3f}mm max={self.max_abs_error_mm:.3f}mm\n"+ f" Within 1mm: {self.pct_within_1mm:.1f}% "+ f"Within 5mm: {self.pct_within_5mm:.1f}%"+ )+++class CalibrationHealthReport(BaseModel):+ """Full health report for one calibration result."""++ model_config = ConfigDict(extra="forbid")++ label: str+ reprojection_error_px: float+ n_observations_used: int+ n_observations_rejected: int+ time_seconds: float+ per_camera: list[PerCameraHealth]+ board_reconstruction: BoardReconstructionHealth | None++ @property+ def summary(self) -> str:+ lines = [+ f"--- {self.label} ---",+ f" Reprojection error: {self.reprojection_error_px:.4f}px "+ f"({self.n_observations_used} obs used, {self.n_observations_rejected} rejected)",+ f" Solver time: {self.time_seconds:.2f}s",+ ]+ if self.board_reconstruction is not None:+ lines.append(self.board_reconstruction.summary)+ for cam in self.per_camera:+ lines.append(cam.summary)+ return "\n".join(lines)+++def compute_calibration_health(+ *,+ result: CalibrationResult,+ label: str,+ all_observations: list[CharucoCornersObservation] | None = None,+) -> CalibrationHealthReport:+ """Compute health metrics for a single calibration result.++ Args:+ result: The calibration to assess.+ label: Human-readable name (e.g. "Anipose", "Pyceres").+ all_observations: If provided, runs board reconstruction accuracy test.+ """+ per_camera: list[PerCameraHealth] = []+ for cam in result.cameras:+ i = cam.intrinsics+ w, h = cam.image_size++ # Focal length sanity: should be roughly image-width-ish (0.5x to 2x)+ avg_focal = (i.fx + i.fy) / 2.0+ focal_reasonable = (w * 0.5) < avg_focal < (w * 3.0)++ # Principal point sanity: should be near image center (within 25%)+ cx_dev = abs(i.cx - w / 2.0) / w+ cy_dev = abs(i.cy - h / 2.0) / h+ pp_reasonable = cx_dev < 0.25 and cy_dev < 0.25++ fx_fy_ratio = i.fx / i.fy if i.fy != 0 else float("inf")++ per_camera.append(PerCameraHealth(+ camera_name=cam.name,+ fx=i.fx, fy=i.fy, cx=i.cx, cy=i.cy,+ k1=i.k1, k2=i.k2,+ image_width=w, image_height=h,+ focal_length_reasonable=focal_reasonable,+ principal_point_reasonable=pp_reasonable,+ fx_fy_ratio=fx_fy_ratio,+ ))++ # Board reconstruction test+ board_health: BoardReconstructionHealth | None = None+ if all_observations is not None and len(all_observations) > 0:+ errors = _compute_board_distance_errors(+ cameras=result.cameras,+ board=result.board,+ all_observations=all_observations,+ )+ if len(errors) > 0:+ abs_errors = np.abs(errors)+ board_health = BoardReconstructionHealth(+ n_distance_measurements=len(errors),+ expected_distance_mm=result.board.square_length_mm,+ mean_error_mm=float(np.mean(errors)),+ median_error_mm=float(np.median(errors)),+ std_error_mm=float(np.std(errors)),+ mean_abs_error_mm=float(np.mean(abs_errors)),+ median_abs_error_mm=float(np.median(abs_errors)),+ max_abs_error_mm=float(np.max(abs_errors)),+ pct_within_1mm=float(np.mean(abs_errors < 1.0) * 100),+ pct_within_5mm=float(np.mean(abs_errors < 5.0) * 100),+ )++ return CalibrationHealthReport(+ label=label,+ reprojection_error_px=result.reprojection_error_px,+ n_observations_used=result.n_observations_used,+ n_observations_rejected=result.n_observations_rejected,+ time_seconds=result.time_seconds,+ per_camera=per_camera,+ board_reconstruction=board_health,+ )+++# =============================================================================+# PER-CAMERA COMPARISON+# =============================================================================+++class CameraComparisonResult(BaseModel):+ """Side-by-side comparison of a single camera across two calibrations."""++ model_config = ConfigDict(extra="forbid")++ camera_name: str++ fx_a: float+ fx_b: float+ fy_a: float+ fy_b: float+ cx_a: float+ cx_b: float+ cy_a: float+ cy_b: float+ k1_a: float+ k1_b: float+ k2_a: float+ k2_b: float++ world_position_a: list[float]+ world_position_b: list[float]++ focal_length_delta_px: float+ principal_point_delta_px: float+ world_position_delta_mm: float+ rotation_angle_delta_deg: float++ @property+ def summary(self) -> str:+ return (+ f" Camera '{self.camera_name}':\n"+ f" Focal length: A=({self.fx_a:.1f}, {self.fy_a:.1f}) "+ f"B=({self.fx_b:.1f}, {self.fy_b:.1f}) "+ f"Δ={self.focal_length_delta_px:.2f}px\n"+ f" Principal point: A=({self.cx_a:.1f}, {self.cy_a:.1f}) "+ f"B=({self.cx_b:.1f}, {self.cy_b:.1f}) "+ f"Δ={self.principal_point_delta_px:.2f}px\n"+ f" Distortion k1: A={self.k1_a:.6f} B={self.k1_b:.6f}\n"+ f" Distortion k2: A={self.k2_a:.6f} B={self.k2_b:.6f}\n"+ f" World position: Δ={self.world_position_delta_mm:.1f}mm\n"+ f" Rotation: Δ={self.rotation_angle_delta_deg:.2f}°"+ )+++# =============================================================================+# AGGREGATE COMPARISON+# =============================================================================+++class CalibrationComparisonResult(BaseModel):+ """Full comparison between two calibration results."""++ model_config = ConfigDict(extra="forbid")++ health_a: CalibrationHealthReport+ health_b: CalibrationHealthReport++ per_camera: list[CameraComparisonResult]++ mean_focal_length_delta_px: float+ max_focal_length_delta_px: float+ mean_world_position_delta_mm: float+ max_world_position_delta_mm: float+ mean_rotation_delta_deg: float+ max_rotation_delta_deg: float++ @property+ def summary(self) -> str:+ label_a = self.health_a.label+ label_b = self.health_b.label++ lines = [+ "=" * 70,+ f"CALIBRATION COMPARISON: {label_a} vs {label_b}",+ "=" * 70,+ "",+ self.health_a.summary,+ "",+ self.health_b.summary,+ "",+ "--- Agreement between solvers ---",+ f" Focal length: mean Δ={self.mean_focal_length_delta_px:.2f}px "+ f"max Δ={self.max_focal_length_delta_px:.2f}px",+ f" World position: mean Δ={self.mean_world_position_delta_mm:.1f}mm "+ f"max Δ={self.max_world_position_delta_mm:.1f}mm",+ f" Rotation: mean Δ={self.mean_rotation_delta_deg:.2f}° "+ f"max Δ={self.max_rotation_delta_deg:.2f}°",+ "",+ "--- Per-camera deltas ---",+ ]+ for cam in self.per_camera:+ lines.append(cam.summary)+ lines.append("=" * 70)+ return "\n".join(lines)+++# =============================================================================+# COMPARISON FUNCTION+# =============================================================================+++def _rotation_angle_between(+ rmat_a: NDArray[np.float64],+ rmat_b: NDArray[np.float64],+) -> float:+ """Angle in degrees between two rotation matrices."""+ R_diff = rmat_a @ rmat_b.T+ trace = np.clip(np.trace(R_diff), -1.0, 3.0)+ angle_rad = np.arccos((trace - 1.0) / 2.0)+ return float(np.degrees(angle_rad))+++def _compare_single_camera(+ cam_a: CameraModel,+ cam_b: CameraModel,+) -> CameraComparisonResult:+ """Compare a single camera across two calibrations."""+ ia = cam_a.intrinsics+ ib = cam_b.intrinsics++ focal_delta = np.sqrt((ia.fx - ib.fx) ** 2 + (ia.fy - ib.fy) ** 2)+ pp_delta = np.sqrt((ia.cx - ib.cx) ** 2 + (ia.cy - ib.cy) ** 2)++ pos_a = cam_a.extrinsics.world_position+ pos_b = cam_b.extrinsics.world_position+ pos_delta = float(np.linalg.norm(pos_a - pos_b))++ rot_delta = _rotation_angle_between(+ cam_a.extrinsics.rotation_matrix,+ cam_b.extrinsics.rotation_matrix,+ )++ return CameraComparisonResult(+ camera_name=cam_a.name,+ fx_a=ia.fx, fx_b=ib.fx,+ fy_a=ia.fy, fy_b=ib.fy,+ cx_a=ia.cx, cx_b=ib.cx,+ cy_a=ia.cy, cy_b=ib.cy,+ k1_a=ia.k1, k1_b=ib.k1,+ k2_a=ia.k2, k2_b=ib.k2,+ world_position_a=pos_a.tolist(),+ world_position_b=pos_b.tolist(),+ focal_length_delta_px=float(focal_delta),+ principal_point_delta_px=float(pp_delta),+ world_position_delta_mm=pos_delta,+ rotation_angle_delta_deg=rot_delta,+ )+++def compare_calibration_results(+ *,+ result_a: CalibrationResult,+ result_b: CalibrationResult,+ label_a: str = "A",+ label_b: str = "B",+ all_observations: list[CharucoCornersObservation] | None = None,+) -> CalibrationComparisonResult:+ """Compare two calibration results with full health reports.++ Both results must have the same camera names (order doesn't matter).++ Args:+ result_a: First calibration result.+ result_b: Second calibration result.+ label_a: Label for first result.+ label_b: Label for second result.+ all_observations: If provided, runs board reconstruction accuracy+ test for both calibrations using the same observations.+ """+ names_a = set(result_a.camera_names)+ names_b = set(result_b.camera_names)+ if names_a != names_b:+ raise ValueError(+ f"Camera name mismatch: {label_a} has {sorted(names_a)}, "+ f"{label_b} has {sorted(names_b)}"+ )++ # Health reports+ health_a = compute_calibration_health(+ result=result_a,+ label=label_a,+ all_observations=all_observations,+ )+ health_b = compute_calibration_health(+ result=result_b,+ label=label_b,+ all_observations=all_observations,+ )++ # Per-camera comparison+ per_camera: list[CameraComparisonResult] = []+ for name in sorted(names_a):+ cam_a = result_a.get_camera(name)+ cam_b = result_b.get_camera(name)+ per_camera.append(_compare_single_camera(cam_a=cam_a, cam_b=cam_b))++ focal_deltas = [c.focal_length_delta_px for c in per_camera]+ pos_deltas = [c.world_position_delta_mm for c in per_camera]+ rot_deltas = [c.rotation_angle_delta_deg for c in per_camera]++ return CalibrationComparisonResult(+ health_a=health_a,+ health_b=health_b,+ per_camera=per_camera,+ mean_focal_length_delta_px=float(np.mean(focal_deltas)),+ max_focal_length_delta_px=float(np.max(focal_deltas)),+ mean_world_position_delta_mm=float(np.mean(pos_deltas)),+ max_world_position_delta_mm=float(np.max(pos_deltas)),+ mean_rotation_delta_deg=float(np.mean(rot_deltas)),+ max_rotation_delta_deg=float(np.max(rot_deltas)),+ )\ No newline at end of filediff --git a/scripts/run_posthoc_calibration.py b/scripts/run_posthoc_calibration.pynew file mode 100644index 00000000..30efab28--- /dev/null+++ b/scripts/run_posthoc_calibration.py@@ -0,0 +1,159 @@+"""+Run posthoc camera calibration from synchronized video files.++Uses VideoGroupHelper to validate that all videos are synchronized (matching+frame counts), then runs the full PosthocPipelineManager calibration pipeline+with either the Anipose or Pyceres solver.++Accepts three input forms:+ - A recording path containing a ``synchronized_videos/`` subfolder+ - A folder path containing video files directly+ - An explicit list of video file paths++Configure the constants in the ``__main__`` block at the bottom.+"""++import logging+import multiprocessing+import time+from pathlib import Path++from freemocap.core.pipeline.posthoc.posthoc_pipeline_manager import PosthocPipelineManager+from freemocap.core.pipeline.posthoc.video_group_helper import VideoGroupHelper+from freemocap.core.pipeline.pipeline_configs import (+ CalibrationPipelineConfig,+ CalibrationSolverMethod,+)+from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry+from skellycam.core.recorders.videos.recording_info import RecordingInfo+++logger = logging.getLogger(__name__)++SYNCHRONIZED_VIDEOS_SUBFOLDER = "synchronized_videos"+VIDEO_EXTENSIONS = {".mp4", ".avi", ".mov", ".mkv"}+POLL_INTERVAL_SECONDS = 0.5+++def _find_videos_in_folder(folder: Path) -> list[str]:+ """Find all video files in a folder. Raises if none are found."""+ videos = sorted(+ str(p) for p in folder.iterdir()+ if p.is_file() and p.suffix.lower() in VIDEO_EXTENSIONS+ )+ if not videos:+ raise FileNotFoundError(+ f"No video files ({', '.join(VIDEO_EXTENSIONS)}) found in {folder}"+ )+ return videos+++def _resolve_video_paths(recording_path: Path | list[str]) -> list[str]:+ """Resolve any of the three supported input forms into a list of video file paths.++ Accepted inputs:+ - ``Path`` to a recording directory containing a ``synchronized_videos/`` subfolder+ - ``Path`` to a folder containing video files directly+ - ``list[str]`` of explicit video file paths+ """+ if isinstance(recording_path, list):+ for p in recording_path:+ if not Path(p).is_file():+ raise FileNotFoundError(f"Video file not found: {p}")+ return sorted(recording_path)++ if not recording_path.is_dir():+ raise NotADirectoryError(f"Not a directory: {recording_path}")++ sync_subfolder = recording_path / SYNCHRONIZED_VIDEOS_SUBFOLDER+ if sync_subfolder.is_dir():+ logger.info(f"Found {SYNCHRONIZED_VIDEOS_SUBFOLDER}/ subfolder — treating as recording path")+ return _find_videos_in_folder(sync_subfolder)++ logger.info(f"No {SYNCHRONIZED_VIDEOS_SUBFOLDER}/ subfolder — treating as video folder")+ return _find_videos_in_folder(recording_path)+++++def run_posthoc_calibration(+ *,+ recording_path: Path ,+ calibration_config:CalibrationPipelineConfig,+) -> None:+ """Validate videos, set up recording directory, and run the calibration pipeline.++ Args:+ recording_path: A recording directory (must contain ``synchronized_videos/``)+ solver_method: Which calibration solver to use.+ """+ video_paths = _resolve_video_paths(recording_path=recording_path)++ # Validate that all videos are synchronized (same frame count)+ logger.info(f"Validating {len(video_paths)} videos via VideoGroupHelper...")+ video_group = VideoGroupHelper.from_video_paths(video_paths=video_paths)+ first_meta = next(iter(video_group.video_metadata_by_id.values()))+ logger.info(+ f"Validation passed: {len(video_group.video_ids)} videos, "+ f"{first_meta.frame_count} frames each, "+ f"{first_meta.width}x{first_meta.height} @ {first_meta.fps:.1f}fps"+ )+++ recording_info = RecordingInfo(+ recording_name=recording_path.name,+ recording_directory=str(recording_path.parent),+ )++++ # Create the multiprocessing infrastructure the pipeline requires+ global_kill_flag: multiprocessing.Value = multiprocessing.Value("b", False)+ worker_registry = WorkerRegistry(+ global_kill_flag=global_kill_flag,+ )+ worker_registry.start_heartbeat()++ pipeline_manager = PosthocPipelineManager(+ global_kill_flag=global_kill_flag,+ worker_registry=worker_registry,+ )++ # Launch the calibration pipeline (starts all worker processes)+ logger.info(f"Launching calibration pipeline with solver: {calibration_config.solver_method.value}")+ pipeline = pipeline_manager.create_calibration_pipeline(+ recording_info=recording_info,+ calibration_config=calibration_config,+ )+ logger.info(f"Pipeline [{pipeline.id}] started")++ # Poll until the pipeline finishes (all worker processes exit)+ try:+ while pipeline.alive:+ time.sleep(POLL_INTERVAL_SECONDS)+ except KeyboardInterrupt:+ logger.info("Interrupted — shutting down pipeline...")+ pipeline_manager.shutdown()+ worker_registry.shutdown_all()+ raise++ logger.info(f"Pipeline [{pipeline.id}] completed. Output saved to {recording_path}")+ pipeline_manager.shutdown()+ worker_registry.shutdown_all()+++if __name__ == "__main__":+ RECORDING_PATH: Path | list[str] = Path().home() / "freemocap_data" / "recordings" / "2026-02-12_18-53-36_GMT-5_calibration"++ CONFIG: CalibrationPipelineConfig = CalibrationPipelineConfig()+ # CONFIG.solver_method = CalibrationSolverMethod.PYCERES+ # CONFIG.charuco_board_x_squares = 5+ # CONFIG.charuco_board_y_squares = 3+ CONFIG.solver_method = CalibrationSolverMethod.ANIPOSE+ CONFIG.charuco_board_x_squares = 5+ CONFIG.charuco_board_y_squares = 3++ run_posthoc_calibration(+ recording_path=RECORDING_PATH,+ calibration_config=CONFIG+ )\ No newline at end of filediff --git a/scripts/run_posthoc_calibration_comparison.py b/scripts/run_posthoc_calibration_comparison.pynew file mode 100644index 00000000..39c3fbb5--- /dev/null+++ b/scripts/run_posthoc_calibration_comparison.py@@ -0,0 +1,229 @@+"""+Run both anipose and pyceres calibration on the same recording data+and compare the results side-by-side.++Runs each solver through the full PosthocPipelineManager pipeline (charuco+detection → calibration → save), preserves both TOML outputs, loads them+back as CalibrationResult, and prints a structured comparison.++Configure the recording path and board parameters in the ``__main__`` block.+"""++import json+import logging+import multiprocessing+import shutil+import time+from pathlib import Path++from freemocap.core.pipeline.posthoc.posthoc_calibration_task.shared.calibration_models import CalibrationResult, \+ CharucoCornersObservation+from freemocap.core.pipeline.posthoc.posthoc_calibration_task.shared.calibration_paths import (+ create_camera_calibration_file_name,+)++from freemocap.core.pipeline.posthoc.posthoc_pipeline_manager import PosthocPipelineManager+from freemocap.core.pipeline.posthoc.video_group_helper import VideoGroupHelper+from freemocap.core.pipeline.pipeline_configs import (+ CalibrationPipelineConfig,+ CalibrationSolverMethod,+)+from skellycam.core.ipc.process_management.worker_registry import WorkerRegistry+from skellycam.core.recorders.videos.recording_info import RecordingInfo++from scripts.compare_calibrations import CalibrationComparisonResult, compare_calibration_results++logger = logging.getLogger(__name__)++SYNCHRONIZED_VIDEOS_SUBFOLDER = "synchronized_videos"+VIDEO_EXTENSIONS = {".mp4", ".avi", ".mov", ".mkv"}+POLL_INTERVAL_SECONDS = 0.5+++def _find_videos_in_folder(folder: Path) -> list[str]:+ """Find all video files in a folder. Raises if none are found."""+ videos = sorted(+ str(p) for p in folder.iterdir()+ if p.is_file() and p.suffix.lower() in VIDEO_EXTENSIONS+ )+ if not videos:+ raise FileNotFoundError(+ f"No video files ({', '.join(VIDEO_EXTENSIONS)}) found in {folder}"+ )+ return videos+++def _resolve_video_paths(recording_path: Path) -> list[str]:+ """Resolve a recording directory into a list of video file paths."""+ if not recording_path.is_dir():+ raise NotADirectoryError(f"Not a directory: {recording_path}")++ sync_subfolder = recording_path / SYNCHRONIZED_VIDEOS_SUBFOLDER+ if sync_subfolder.is_dir():+ logger.info(f"Found {SYNCHRONIZED_VIDEOS_SUBFOLDER}/ subfolder")+ return _find_videos_in_folder(sync_subfolder)++ return _find_videos_in_folder(recording_path)+++def _run_single_pipeline(+ *,+ recording_path: Path,+ calibration_config: CalibrationPipelineConfig,+) -> None:+ """Run one calibration pipeline to completion."""+ recording_info = RecordingInfo(+ recording_name=recording_path.name,+ recording_directory=str(recording_path.parent),+ )++ global_kill_flag = multiprocessing.Value("b", False)+ worker_registry = WorkerRegistry(global_kill_flag=global_kill_flag)+ worker_registry.start_heartbeat()++ pipeline_manager = PosthocPipelineManager(+ global_kill_flag=global_kill_flag,+ worker_registry=worker_registry,+ )++ solver_name = calibration_config.solver_method.value+ logger.info(f"Launching {solver_name} calibration pipeline...")+ pipeline = pipeline_manager.create_calibration_pipeline(+ recording_info=recording_info,+ calibration_config=calibration_config,+ )+ logger.info(f"Pipeline [{pipeline.id}] started ({solver_name})")++ try:+ while pipeline.alive:+ time.sleep(POLL_INTERVAL_SECONDS)+ except KeyboardInterrupt:+ logger.info("Interrupted — shutting down pipeline...")+ pipeline_manager.shutdown()+ worker_registry.shutdown_all()+ raise++ logger.info(f"Pipeline [{pipeline.id}] completed ({solver_name})")+ pipeline_manager.shutdown()+ worker_registry.shutdown_all()+++def run_both_and_compare(+ *,+ recording_path: Path,+ base_config: CalibrationPipelineConfig,+) -> CalibrationComparisonResult:+ """Run both anipose and pyceres calibration, then compare results.++ Runs each solver sequentially through the full pipeline. After each+ run the calibration TOML is copied to a solver-specific filename so+ the second run doesn't overwrite the first.++ Args:+ recording_path: Recording directory containing synchronized_videos/.+ base_config: Pipeline config with board parameters. The solver_method+ field is overridden for each run.++ Returns:+ CalibrationComparisonResult with per-camera and aggregate metrics.+ """+ # Validate videos once up front+ video_paths = _resolve_video_paths(recording_path=recording_path)+ video_group = VideoGroupHelper.from_video_paths(video_paths=video_paths)+ first_meta = next(iter(video_group.video_metadata_by_id.values()))+ logger.info(+ f"Validated {len(video_group.video_ids)} videos, "+ f"{first_meta.frame_count} frames each, "+ f"{first_meta.width}x{first_meta.height} @ {first_meta.fps:.1f}fps"+ )++ calibration_filename = create_camera_calibration_file_name(+ recording_name=recording_path.name,+ )+ pipeline_output_toml = recording_path / calibration_filename++ # ---- Run anipose ----+ anipose_config = base_config.model_copy()+ anipose_config.solver_method = CalibrationSolverMethod.ANIPOSE++ _run_single_pipeline(+ recording_path=recording_path,+ calibration_config=anipose_config,+ )++ anipose_toml = recording_path / f"{recording_path.name}_anipose_calibration.toml"+ if not pipeline_output_toml.is_file():+ raise FileNotFoundError(+ f"Anipose pipeline did not produce expected output: {pipeline_output_toml}"+ )+ shutil.copy2(pipeline_output_toml, anipose_toml)+ logger.info(f"Anipose result preserved at: {anipose_toml}")++ # ---- Run pyceres ----+ pyceres_config = base_config.model_copy()+ pyceres_config.solver_method = CalibrationSolverMethod.PYCERES++ _run_single_pipeline(+ recording_path=recording_path,+ calibration_config=pyceres_config,+ )++ pyceres_toml = recording_path / f"{recording_path.name}_pyceres_calibration.toml"+ if not pipeline_output_toml.is_file():+ raise FileNotFoundError(+ f"Pyceres pipeline did not produce expected output: {pipeline_output_toml}"+ )+ shutil.copy2(pipeline_output_toml, pyceres_toml)+ logger.info(f"Pyceres result preserved at: {pyceres_toml}")++ # ---- Load and compare ----+ anipose_result = CalibrationResult.load_anipose_toml(path=anipose_toml)+ pyceres_result = CalibrationResult.load_anipose_toml(path=pyceres_toml)++ # Load saved observations for board reconstruction accuracy test+ observations_json_path = recording_path / "charuco_observations.json"+ all_observations: list[CharucoCornersObservation] | None = None+ if observations_json_path.is_file():+ raw_list = json.loads(observations_json_path.read_text())+ all_observations = [CharucoCornersObservation.model_validate(o) for o in raw_list]+ logger.info(f"Loaded {len(all_observations)} observations for board reconstruction test")+ else:+ logger.warning(+ f"No observations file at {observations_json_path} — "+ f"board reconstruction test will be skipped"+ )++ comparison = compare_calibration_results(+ result_a=anipose_result,+ result_b=pyceres_result,+ label_a="Anipose",+ label_b="Pyceres",+ all_observations=all_observations,+ )++ # Save comparison as JSON+ comparison_json_path = recording_path / f"{recording_path.name}_calibration_comparison.json"+ comparison_json_path.write_text(comparison.model_dump_json(indent=2))+ logger.info(f"Comparison saved to: {comparison_json_path}")++ return comparison+++if __name__ == "__main__":++ RECORDING_PATH = (+ Path.home()+ / "freemocap_data"+ / "recordings"+ / "2026-02-11_14-35-59_GMT-5_calibration"+ )++ CONFIG = CalibrationPipelineConfig()+ CONFIG.charuco_board_x_squares = 5+ CONFIG.charuco_board_y_squares = 3+ comparison = run_both_and_compare(+ recording_path=RECORDING_PATH,+ base_config=CONFIG,+ )++ print("\n" + comparison.summary)\ No newline at end of filediff --git a/scripts/run_tests.sh b/scripts/run_tests.shnew file mode 100644index 00000000..f3df9bcc--- /dev/null+++ b/scripts/run_tests.sh@@ -0,0 +1,95 @@+#!/usr/bin/env bash+set -euo pipefail++# =============================================================================+# run_tests.sh — Run all backend + frontend tests+#+# Usage:+# ./scripts/run_tests.sh Run everything+# ./scripts/run_tests.sh backend Backend only+# ./scripts/run_tests.sh frontend Frontend only+# ./scripts/run_tests.sh sync Just the frontend/backend sync tests+# =============================================================================++SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"+REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"++RED='\033[0;31m'+GREEN='\033[0;32m'+CYAN='\033[0;36m'+RESET='\033[0m'++passed=0+failed=0++run_step() {+ local label="$1"+ shift+ echo -e "\n${CYAN}━━━ ${label} ━━━${RESET}\n"+ if "$@"; then+ echo -e "\n${GREEN}✓ ${label} passed${RESET}"+ ((passed++))+ else+ echo -e "\n${RED}✗ ${label} FAILED${RESET}"+ ((failed++))+ fi+}++run_backend() {+ cd "$REPO_ROOT"+ run_step "Backend: Schema contract tests" \+ uv run pytest freemocap/tests/test_schema_contract.py -v+ run_step "Backend: SettingsManager unit tests" \+ uv run pytest freemocap/tests/test_settings_manager.py -v+ run_step "Backend: HTTP endpoint integration tests" \+ uv run pytest freemocap/tests/test_http_config_endpoints.py -v+ run_step "Backend: WebSocket protocol tests" \+ uv run pytest freemocap/tests/test_websocket_settings_protocol.py -v+}++run_frontend() {+ cd "$REPO_ROOT/freemocap-ui"+ run_step "Frontend: Vitest suite" \+ npx vitest run+}++run_sync() {+ cd "$REPO_ROOT"+ run_step "Sync tests (schema + settings + HTTP + WebSocket)" \+ uv run pytest \+ freemocap/tests/test_schema_contract.py \+ freemocap/tests/test_settings_manager.py \+ freemocap/tests/test_http_config_endpoints.py \+ freemocap/tests/test_websocket_settings_protocol.py \+ -v+}++# --- Main ---++target="${1:-all}"++echo -e "${CYAN}╔══════════════════════════════════════════╗${RESET}"+echo -e "${CYAN}║ FreeMoCap Test Runner ║${RESET}"+echo -e "${CYAN}║ Target: ${target}$(printf '%*s' $((29 - ${#target})) '')║${RESET}"+echo -e "${CYAN}╚══════════════════════════════════════════╝${RESET}"++case "$target" in+ backend) run_backend ;;+ frontend) run_frontend ;;+ sync) run_sync ;;+ all) run_backend; run_frontend ;;+ *)+ echo "Unknown target: $target"+ echo "Usage: $0 [all|backend|frontend|sync]"+ exit 1+ ;;+esac++echo -e "\n${CYAN}━━━ Summary ━━━${RESET}"+echo -e "${GREEN}Passed: ${passed}${RESET}"+if [ "$failed" -gt 0 ]; then+ echo -e "${RED}Failed: ${failed}${RESET}"+ exit 1+else+ echo -e "${GREEN}All test groups passed!${RESET}"+fidiff --git a/uv.lock b/uv.lockindex 91460b3c..d96ba94a 100644--- a/uv.lock+++ b/uv.lock@@ -1,42 +1,49 @@version = 1+revision = 3requires-python = ">=3.11"resolution-markers = [- "python_full_version < '3.12' and platform_system == 'Darwin'",- "python_full_version < '3.12' and platform_machine == 'aarch64' and platform_system == 'Linux'",- "(python_full_version < '3.12' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version < '3.12' and platform_system != 'Darwin' and platform_system != 'Linux')",- "python_full_version == '3.12.*' and platform_system == 'Darwin'",- "python_full_version >= '3.13' and platform_system == 'Darwin'",- "python_full_version == '3.12.*' and platform_machine == 'aarch64' and platform_system == 'Linux'",- "python_full_version >= '3.13' and platform_machine == 'aarch64' and platform_system == 'Linux'",- "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version == '3.12.*' and platform_system != 'Darwin' and platform_system != 'Linux')",- "(python_full_version >= '3.13' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version >= '3.13' and platform_system != 'Darwin' and platform_system != 'Linux')",+ "python_full_version >= '3.14' and sys_platform == 'darwin'",+ "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin'",+ "python_full_version >= '3.14' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "python_full_version >= '3.12' and python_full_version < '3.14' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "python_full_version >= '3.14' and sys_platform == 'win32'",+ "python_full_version >= '3.14' and sys_platform == 'emscripten'",+ "(python_full_version >= '3.14' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",+ "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32'",+ "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten'",+ "(python_full_version >= '3.12' and python_full_version < '3.14' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",+ "python_full_version < '3.12' and sys_platform == 'darwin'",+ "python_full_version < '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "python_full_version < '3.12' and sys_platform == 'win32'",+ "python_full_version < '3.12' and sys_platform == 'emscripten'",+ "(python_full_version < '3.12' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.12' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",][[package]]name = "absl-py"-version = "2.3.1"+version = "2.4.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/10/2a/c93173ffa1b39c1d0395b7e842bbdc62e556ca9d8d3b5572926f3e4ca752/absl_py-2.3.1.tar.gz", hash = "sha256:a97820526f7fbfd2ec1bce83f3f25e3a14840dac0d8e02a0b71cd75db3f77fc9", size = 116588 }+sdist = { url = "https://files.pythonhosted.org/packages/64/c7/8de93764ad66968d19329a7e0c147a2bb3c7054c554d4a119111b8f9440f/absl_py-2.4.0.tar.gz", hash = "sha256:8c6af82722b35cf71e0f4d1d47dcaebfff286e27110a99fc359349b247dfb5d4", size = 116543, upload-time = "2026-01-28T10:17:05.322Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/8f/aa/ba0014cc4659328dc818a28827be78e6d97312ab0cb98105a770924dc11e/absl_py-2.3.1-py3-none-any.whl", hash = "sha256:eeecf07f0c2a93ace0772c92e596ace6d3d3996c042b2128459aaae2a76de11d", size = 135811 },+ { url = "https://files.pythonhosted.org/packages/18/a6/907a406bb7d359e6a63f99c313846d9eec4f7e6f7437809e03aa00fa3074/absl_py-2.4.0-py3-none-any.whl", hash = "sha256:88476fd881ca8aab94ffa78b7b6c632a782ab3ba1cd19c9bd423abc4fb4cd28d", size = 135750, upload-time = "2026-01-28T10:17:04.19Z" },][[package]]name = "ajc27-freemocap-blender-addon"version = "2024.12.1032"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/04/e6/0077aa5a43e54b321456633a900ccbb13ee1582cffc599f9b6b2e6ab4d23/ajc27_freemocap_blender_addon-2024.12.1032.tar.gz", hash = "sha256:cc1d01fbdb7b5ed373e8bf1c4eef876bf3688292f9fced36edabb6456d1c8086", size = 1654203 }+sdist = { url = "https://files.pythonhosted.org/packages/04/e6/0077aa5a43e54b321456633a900ccbb13ee1582cffc599f9b6b2e6ab4d23/ajc27_freemocap_blender_addon-2024.12.1032.tar.gz", hash = "sha256:cc1d01fbdb7b5ed373e8bf1c4eef876bf3688292f9fced36edabb6456d1c8086", size = 1654203, upload-time = "2024-12-12T13:37:54.445Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/48/d9/9d87e245b8c58a6dc648e65497a923dfada3156f9a2f3b09e56bfc971683/ajc27_freemocap_blender_addon-2024.12.1032-py3-none-any.whl", hash = "sha256:3b129f3dd7b78ce4f9b03af3fc682c2213f725cbc77805ddfda4e96ff30f8cfe", size = 1897863 },+ { url = "https://files.pythonhosted.org/packages/48/d9/9d87e245b8c58a6dc648e65497a923dfada3156f9a2f3b09e56bfc971683/ajc27_freemocap_blender_addon-2024.12.1032-py3-none-any.whl", hash = "sha256:3b129f3dd7b78ce4f9b03af3fc682c2213f725cbc77805ddfda4e96ff30f8cfe", size = 1897863, upload-time = "2024-12-12T13:37:52.655Z" },][[package]]name = "altgraph"-version = "0.17.4"+version = "0.17.5"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/de/a8/7145824cf0b9e3c28046520480f207df47e927df83aa9555fb47f8505922/altgraph-0.17.4.tar.gz", hash = "sha256:1b5afbb98f6c4dcadb2e2ae6ab9fa994bbb8c1d75f4fa96d340f9437ae454406", size = 48418 }+sdist = { url = "https://files.pythonhosted.org/packages/7e/f8/97fdf103f38fed6792a1601dbc16cc8aac56e7459a9fff08c812d8ae177a/altgraph-0.17.5.tar.gz", hash = "sha256:c87b395dd12fabde9c99573a9749d67da8d29ef9de0125c7f536699b4a9bc9e7", size = 48428, upload-time = "2025-11-21T20:35:50.583Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/4d/3f/3bc3f1d83f6e4a7fcb834d3720544ca597590425be5ba9db032b2bf322a2/altgraph-0.17.4-py2.py3-none-any.whl", hash = "sha256:642743b4750de17e655e6711601b077bc6598dbfa3ba5fa2b2a35ce12b508dff", size = 21212 },+ { url = "https://files.pythonhosted.org/packages/a9/ba/000a1996d4308bc65120167c21241a3b205464a2e0b58deda26ae8ac21d1/altgraph-0.17.5-py2.py3-none-any.whl", hash = "sha256:f3a22400bce1b0c701683820ac4f3b159cd301acab067c51c653e06961600597", size = 21228, upload-time = "2025-11-21T20:35:49.444Z" },][[package]]@@ -47,55 +54,60 @@ dependencies = [{ name = "numba" },{ name = "numpy" },{ name = "opencv-contrib-python" },- { name = "pandas" },+ { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.14'" },+ { name = "pandas", version = "3.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.14'" },{ name = "scipy" },{ name = "toml" },{ name = "tqdm" },]-sdist = { url = "https://files.pythonhosted.org/packages/67/62/371f2f863cf622005cbd416c3c3ef0a3b6affb8457279dfb7d907a554404/aniposelib-0.7.2.tar.gz", hash = "sha256:fec4ea30e2673385fa4574364bf949fbc27e9416901d57f04ec1c46bc665619c", size = 22420 }+sdist = { url = "https://files.pythonhosted.org/packages/67/62/371f2f863cf622005cbd416c3c3ef0a3b6affb8457279dfb7d907a554404/aniposelib-0.7.2.tar.gz", hash = "sha256:fec4ea30e2673385fa4574364bf949fbc27e9416901d57f04ec1c46bc665619c", size = 22420, upload-time = "2025-06-04T21:33:35.814Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/b9/92/f42ac9b51451f051be1edae7bb33171b270e671b7ad97a9bcd98f4ca4af0/aniposelib-0.7.2-py3-none-any.whl", hash = "sha256:07534e7ba3554770bd4f04c18526bba75559897df4abc7145c4c84e0596c3b01", size = 22824 },+ { url = "https://files.pythonhosted.org/packages/b9/92/f42ac9b51451f051be1edae7bb33171b270e671b7ad97a9bcd98f4ca4af0/aniposelib-0.7.2-py3-none-any.whl", hash = "sha256:07534e7ba3554770bd4f04c18526bba75559897df4abc7145c4c84e0596c3b01", size = 22824, upload-time = "2025-06-04T21:33:33.759Z" },][[package]]name = "annotated-doc"version = "0.0.4"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288 }+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303 },+ { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },][[package]]name = "annotated-types"version = "0.7.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 }+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 },+ { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },][[package]]name = "anyio"-version = "4.11.0"+version = "4.12.1"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "idna" },- { name = "sniffio" },{ name = "typing-extensions", marker = "python_full_version < '3.13'" },]-sdist = { url = "https://files.pythonhosted.org/packages/c6/78/7d432127c41b50bccba979505f272c16cbcadcc33645d5fa3a738110ae75/anyio-4.11.0.tar.gz", hash = "sha256:82a8d0b81e318cc5ce71a5f1f8b5c4e63619620b63141ef8c995fa0db95a57c4", size = 219094 }+sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/15/b3/9b1a8074496371342ec1e796a96f99c82c945a339cd81a8e73de28b4cf9e/anyio-4.11.0-py3-none-any.whl", hash = "sha256:0287e96f4d26d4149305414d4e3bc32f0dcd0862365a4bddea19d7a1ec38c4fc", size = 109097 },+ { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" },][[package]]-name = "attrs"-version = "25.4.0"+name = "build"+version = "1.4.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251 }+dependencies = [+ { name = "colorama", marker = "(os_name == 'nt' and platform_machine != 'aarch64' and sys_platform == 'linux') or (os_name == 'nt' and sys_platform != 'darwin' and sys_platform != 'linux')" },+ { name = "packaging" },+ { name = "pyproject-hooks" },+]+sdist = { url = "https://files.pythonhosted.org/packages/42/18/94eaffda7b329535d91f00fe605ab1f1e5cd68b2074d03f255c7d250687d/build-1.4.0.tar.gz", hash = "sha256:f1b91b925aa322be454f8330c6fb48b465da993d1e7e7e6fa35027ec49f3c936", size = 50054, upload-time = "2026-01-08T16:41:47.696Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615 },+ { url = "https://files.pythonhosted.org/packages/c5/0d/84a4380f930db0010168e0aa7b7a8fed9ba1835a8fbb1472bc6d0201d529/build-1.4.0-py3-none-any.whl", hash = "sha256:6a07c1b8eb6f2b311b96fcbdbce5dab5fe637ffda0fd83c9cac622e927501596", size = 24141, upload-time = "2026-01-08T16:41:46.453Z" },][[package]]@@ -108,18 +120,18 @@ dependencies = [{ name = "lexid" },{ name = "toml" },]-sdist = { url = "https://files.pythonhosted.org/packages/8f/8a/cc13e816e9f0849dce423b904b06fd91b5444cba6df3200d512a702f2e95/bumpver-2025.1131.tar.gz", hash = "sha256:a35fd2d43a5f65f014035c094866bd3bd6c739606f29fd41246d6ec6e839d3f9", size = 115372 }+sdist = { url = "https://files.pythonhosted.org/packages/8f/8a/cc13e816e9f0849dce423b904b06fd91b5444cba6df3200d512a702f2e95/bumpver-2025.1131.tar.gz", hash = "sha256:a35fd2d43a5f65f014035c094866bd3bd6c739606f29fd41246d6ec6e839d3f9", size = 115372, upload-time = "2025-07-02T20:36:11.982Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/1d/5b/2d5ea6802495ee4506721977be522804314aa66ad629d9356e3c7e5af4a6/bumpver-2025.1131-py2.py3-none-any.whl", hash = "sha256:c02527f6ed7887afbc06c07630047b24a9f9d02d544a65639e99bf8b92aaa674", size = 65361 },+ { url = "https://files.pythonhosted.org/packages/1d/5b/2d5ea6802495ee4506721977be522804314aa66ad629d9356e3c7e5af4a6/bumpver-2025.1131-py2.py3-none-any.whl", hash = "sha256:c02527f6ed7887afbc06c07630047b24a9f9d02d544a65639e99bf8b92aaa674", size = 65361, upload-time = "2025-07-02T20:36:10.103Z" },][[package]]name = "certifi"-version = "2025.11.12"+version = "2026.1.4"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/a2/8c/58f469717fa48465e4a50c014a0400602d3c437d7c0c468e17ada824da3a/certifi-2025.11.12.tar.gz", hash = "sha256:d8ab5478f2ecd78af242878415affce761ca6bc54a22a27e026d7c25357c3316", size = 160538 }+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/70/7d/9bc192684cea499815ff478dfcdc13835ddf401365057044fb721ec6bddb/certifi-2025.11.12-py3-none-any.whl", hash = "sha256:97de8790030bbd5c2d96b7ec782fc2f7820ef8dba6db909ccf95449f2d062d4b", size = 159438 },+ { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },][[package]]@@ -129,161 +141,161 @@ source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "pycparser", marker = "implementation_name != 'PyPy'" },]-sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588 }-wheels = [- { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344 },- { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560 },- { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613 },- { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476 },- { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374 },- { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597 },- { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574 },- { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971 },- { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972 },- { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078 },- { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076 },- { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820 },- { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635 },- { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271 },- { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048 },- { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529 },- { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097 },- { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983 },- { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519 },- { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572 },- { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963 },- { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361 },- { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932 },- { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557 },- { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762 },- { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230 },- { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043 },- { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446 },- { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101 },- { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948 },- { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422 },- { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499 },- { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928 },- { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302 },- { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909 },- { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402 },- { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780 },- { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320 },- { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487 },- { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049 },- { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793 },- { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300 },- { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244 },- { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828 },- { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926 },- { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328 },- { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650 },- { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687 },- { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773 },- { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013 },- { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593 },- { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354 },- { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480 },- { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584 },- { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443 },- { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437 },- { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487 },- { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726 },- { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195 },+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" },+ { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" },+ { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" },+ { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" },+ { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" },+ { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" },+ { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" },+ { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" },+ { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" },+ { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" },+ { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" },+ { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" },+ { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" },+ { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" },+ { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" },+ { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" },+ { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" },+ { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" },+ { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" },+ { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" },+ { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" },+ { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" },+ { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" },+ { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" },+ { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" },+ { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" },+ { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" },+ { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" },+ { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" },+ { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" },+ { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" },+ { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" },+ { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" },+ { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" },+ { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },+ { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },+ { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },+ { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" },+ { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" },+ { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" },+ { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" },+ { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" },+ { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" },+ { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" },+ { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" },+ { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" },+ { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" },+ { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" },+ { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" },+ { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" },+ { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" },+ { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" },+ { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" },+ { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" },+ { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" },+ { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" },+ { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" },+ { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" },+ { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },][[package]]name = "charset-normalizer"version = "3.4.4"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418 }-wheels = [- { url = "https://files.pythonhosted.org/packages/ed/27/c6491ff4954e58a10f69ad90aca8a1b6fe9c5d3c6f380907af3c37435b59/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8", size = 206988 },- { url = "https://files.pythonhosted.org/packages/94/59/2e87300fe67ab820b5428580a53cad894272dbb97f38a7a814a2a1ac1011/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0", size = 147324 },- { url = "https://files.pythonhosted.org/packages/07/fb/0cf61dc84b2b088391830f6274cb57c82e4da8bbc2efeac8c025edb88772/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3", size = 142742 },- { url = "https://files.pythonhosted.org/packages/62/8b/171935adf2312cd745d290ed93cf16cf0dfe320863ab7cbeeae1dcd6535f/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc", size = 160863 },- { url = "https://files.pythonhosted.org/packages/09/73/ad875b192bda14f2173bfc1bc9a55e009808484a4b256748d931b6948442/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897", size = 157837 },- { url = "https://files.pythonhosted.org/packages/6d/fc/de9cce525b2c5b94b47c70a4b4fb19f871b24995c728e957ee68ab1671ea/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381", size = 151550 },- { url = "https://files.pythonhosted.org/packages/55/c2/43edd615fdfba8c6f2dfbd459b25a6b3b551f24ea21981e23fb768503ce1/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815", size = 149162 },- { url = "https://files.pythonhosted.org/packages/03/86/bde4ad8b4d0e9429a4e82c1e8f5c659993a9a863ad62c7df05cf7b678d75/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0", size = 150019 },- { url = "https://files.pythonhosted.org/packages/1f/86/a151eb2af293a7e7bac3a739b81072585ce36ccfb4493039f49f1d3cae8c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161", size = 143310 },- { url = "https://files.pythonhosted.org/packages/b5/fe/43dae6144a7e07b87478fdfc4dbe9efd5defb0e7ec29f5f58a55aeef7bf7/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4", size = 162022 },- { url = "https://files.pythonhosted.org/packages/80/e6/7aab83774f5d2bca81f42ac58d04caf44f0cc2b65fc6db2b3b2e8a05f3b3/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89", size = 149383 },- { url = "https://files.pythonhosted.org/packages/4f/e8/b289173b4edae05c0dde07f69f8db476a0b511eac556dfe0d6bda3c43384/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569", size = 159098 },- { url = "https://files.pythonhosted.org/packages/d8/df/fe699727754cae3f8478493c7f45f777b17c3ef0600e28abfec8619eb49c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224", size = 152991 },- { url = "https://files.pythonhosted.org/packages/1a/86/584869fe4ddb6ffa3bd9f491b87a01568797fb9bd8933f557dba9771beaf/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a", size = 99456 },- { url = "https://files.pythonhosted.org/packages/65/f6/62fdd5feb60530f50f7e38b4f6a1d5203f4d16ff4f9f0952962c044e919a/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016", size = 106978 },- { url = "https://files.pythonhosted.org/packages/7a/9d/0710916e6c82948b3be62d9d398cb4fcf4e97b56d6a6aeccd66c4b2f2bd5/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1", size = 99969 },- { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425 },- { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162 },- { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558 },- { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497 },- { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240 },- { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471 },- { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864 },- { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647 },- { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110 },- { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839 },- { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667 },- { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535 },- { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816 },- { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694 },- { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131 },- { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390 },- { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091 },- { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936 },- { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180 },- { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346 },- { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874 },- { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076 },- { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601 },- { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376 },- { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825 },- { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583 },- { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366 },- { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300 },- { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465 },- { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404 },- { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092 },- { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408 },- { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746 },- { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889 },- { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641 },- { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779 },- { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035 },- { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542 },- { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524 },- { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395 },- { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680 },- { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045 },- { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687 },- { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014 },- { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044 },- { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940 },- { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104 },- { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743 },- { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402 },+sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/ed/27/c6491ff4954e58a10f69ad90aca8a1b6fe9c5d3c6f380907af3c37435b59/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8", size = 206988, upload-time = "2025-10-14T04:40:33.79Z" },+ { url = "https://files.pythonhosted.org/packages/94/59/2e87300fe67ab820b5428580a53cad894272dbb97f38a7a814a2a1ac1011/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0", size = 147324, upload-time = "2025-10-14T04:40:34.961Z" },+ { url = "https://files.pythonhosted.org/packages/07/fb/0cf61dc84b2b088391830f6274cb57c82e4da8bbc2efeac8c025edb88772/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3", size = 142742, upload-time = "2025-10-14T04:40:36.105Z" },+ { url = "https://files.pythonhosted.org/packages/62/8b/171935adf2312cd745d290ed93cf16cf0dfe320863ab7cbeeae1dcd6535f/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc", size = 160863, upload-time = "2025-10-14T04:40:37.188Z" },+ { url = "https://files.pythonhosted.org/packages/09/73/ad875b192bda14f2173bfc1bc9a55e009808484a4b256748d931b6948442/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897", size = 157837, upload-time = "2025-10-14T04:40:38.435Z" },+ { url = "https://files.pythonhosted.org/packages/6d/fc/de9cce525b2c5b94b47c70a4b4fb19f871b24995c728e957ee68ab1671ea/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381", size = 151550, upload-time = "2025-10-14T04:40:40.053Z" },+ { url = "https://files.pythonhosted.org/packages/55/c2/43edd615fdfba8c6f2dfbd459b25a6b3b551f24ea21981e23fb768503ce1/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815", size = 149162, upload-time = "2025-10-14T04:40:41.163Z" },+ { url = "https://files.pythonhosted.org/packages/03/86/bde4ad8b4d0e9429a4e82c1e8f5c659993a9a863ad62c7df05cf7b678d75/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0", size = 150019, upload-time = "2025-10-14T04:40:42.276Z" },+ { url = "https://files.pythonhosted.org/packages/1f/86/a151eb2af293a7e7bac3a739b81072585ce36ccfb4493039f49f1d3cae8c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161", size = 143310, upload-time = "2025-10-14T04:40:43.439Z" },+ { url = "https://files.pythonhosted.org/packages/b5/fe/43dae6144a7e07b87478fdfc4dbe9efd5defb0e7ec29f5f58a55aeef7bf7/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4", size = 162022, upload-time = "2025-10-14T04:40:44.547Z" },+ { url = "https://files.pythonhosted.org/packages/80/e6/7aab83774f5d2bca81f42ac58d04caf44f0cc2b65fc6db2b3b2e8a05f3b3/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89", size = 149383, upload-time = "2025-10-14T04:40:46.018Z" },+ { url = "https://files.pythonhosted.org/packages/4f/e8/b289173b4edae05c0dde07f69f8db476a0b511eac556dfe0d6bda3c43384/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569", size = 159098, upload-time = "2025-10-14T04:40:47.081Z" },+ { url = "https://files.pythonhosted.org/packages/d8/df/fe699727754cae3f8478493c7f45f777b17c3ef0600e28abfec8619eb49c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224", size = 152991, upload-time = "2025-10-14T04:40:48.246Z" },+ { url = "https://files.pythonhosted.org/packages/1a/86/584869fe4ddb6ffa3bd9f491b87a01568797fb9bd8933f557dba9771beaf/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a", size = 99456, upload-time = "2025-10-14T04:40:49.376Z" },+ { url = "https://files.pythonhosted.org/packages/65/f6/62fdd5feb60530f50f7e38b4f6a1d5203f4d16ff4f9f0952962c044e919a/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016", size = 106978, upload-time = "2025-10-14T04:40:50.844Z" },+ { url = "https://files.pythonhosted.org/packages/7a/9d/0710916e6c82948b3be62d9d398cb4fcf4e97b56d6a6aeccd66c4b2f2bd5/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1", size = 99969, upload-time = "2025-10-14T04:40:52.272Z" },+ { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" },+ { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" },+ { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" },+ { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" },+ { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" },+ { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" },+ { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" },+ { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" },+ { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" },+ { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" },+ { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" },+ { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" },+ { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" },+ { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" },+ { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" },+ { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" },+ { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" },+ { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" },+ { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" },+ { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" },+ { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" },+ { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" },+ { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" },+ { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" },+ { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" },+ { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" },+ { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" },+ { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" },+ { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" },+ { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" },+ { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" },+ { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" },+ { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" },+ { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" },+ { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" },+ { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" },+ { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" },+ { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" },+ { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" },+ { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" },+ { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" },+ { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" },+ { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" },+ { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" },+ { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" },+ { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" },+ { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" },+ { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" },+ { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" },][[package]]name = "click"-version = "8.3.0"+version = "8.3.1"source = { registry = "https://pypi.org/simple" }dependencies = [- { name = "colorama", marker = "platform_system == 'Windows'" },+ { name = "colorama", marker = "sys_platform == 'win32'" },]-sdist = { url = "https://files.pythonhosted.org/packages/46/61/de6cd827efad202d7057d93e0fed9294b96952e188f7384832791c7b2254/click-8.3.0.tar.gz", hash = "sha256:e7b8232224eba16f4ebe410c25ced9f7875cb5f3263ffc93cc3e8da705e229c4", size = 276943 }+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/db/d3/9dcc0f5797f070ec8edf30fbadfb200e71d9db6b84d211e3b2085a7589a0/click-8.3.0-py3-none-any.whl", hash = "sha256:9b9f285302c6e3064f4330c05f05b81945b2a39544279343e6e7c5f27a9baddc", size = 107295 },+ { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },][[package]]name = "colorama"version = "0.4.6"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 }+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },+ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },][[package]]@@ -293,175 +305,175 @@ source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "numpy" },]-sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174 }-wheels = [- { url = "https://files.pythonhosted.org/packages/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773 },- { url = "https://files.pythonhosted.org/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149 },- { url = "https://files.pythonhosted.org/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222 },- { url = "https://files.pythonhosted.org/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234 },- { url = "https://files.pythonhosted.org/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555 },- { url = "https://files.pythonhosted.org/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238 },- { url = "https://files.pythonhosted.org/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218 },- { url = "https://files.pythonhosted.org/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867 },- { url = "https://files.pythonhosted.org/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677 },- { url = "https://files.pythonhosted.org/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234 },- { url = "https://files.pythonhosted.org/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123 },- { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419 },- { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979 },- { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653 },- { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536 },- { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397 },- { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601 },- { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288 },- { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386 },- { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018 },- { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567 },- { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655 },- { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257 },- { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034 },- { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672 },- { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234 },- { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169 },- { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859 },- { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062 },- { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932 },- { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024 },- { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578 },- { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524 },- { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730 },- { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897 },- { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751 },- { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486 },- { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106 },- { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548 },- { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297 },- { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023 },- { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157 },- { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570 },- { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713 },- { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189 },- { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251 },- { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810 },- { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871 },- { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264 },- { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819 },- { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650 },- { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833 },- { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692 },- { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424 },- { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300 },- { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769 },- { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892 },- { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748 },- { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554 },- { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118 },- { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555 },- { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295 },- { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027 },- { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428 },- { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331 },- { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831 },- { url = "https://files.pythonhosted.org/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809 },- { url = "https://files.pythonhosted.org/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593 },- { url = "https://files.pythonhosted.org/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202 },- { url = "https://files.pythonhosted.org/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207 },- { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315 },+sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773, upload-time = "2025-07-26T12:01:02.277Z" },+ { url = "https://files.pythonhosted.org/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149, upload-time = "2025-07-26T12:01:04.072Z" },+ { url = "https://files.pythonhosted.org/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222, upload-time = "2025-07-26T12:01:05.688Z" },+ { url = "https://files.pythonhosted.org/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234, upload-time = "2025-07-26T12:01:07.054Z" },+ { url = "https://files.pythonhosted.org/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555, upload-time = "2025-07-26T12:01:08.801Z" },+ { url = "https://files.pythonhosted.org/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238, upload-time = "2025-07-26T12:01:10.319Z" },+ { url = "https://files.pythonhosted.org/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218, upload-time = "2025-07-26T12:01:12.659Z" },+ { url = "https://files.pythonhosted.org/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867, upload-time = "2025-07-26T12:01:15.533Z" },+ { url = "https://files.pythonhosted.org/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677, upload-time = "2025-07-26T12:01:17.088Z" },+ { url = "https://files.pythonhosted.org/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234, upload-time = "2025-07-26T12:01:18.256Z" },+ { url = "https://files.pythonhosted.org/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123, upload-time = "2025-07-26T12:01:19.848Z" },+ { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" },+ { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" },+ { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" },+ { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" },+ { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" },+ { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" },+ { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" },+ { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" },+ { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" },+ { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" },+ { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" },+ { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" },+ { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" },+ { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" },+ { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" },+ { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" },+ { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" },+ { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" },+ { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" },+ { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" },+ { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" },+ { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" },+ { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" },+ { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" },+ { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" },+ { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" },+ { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" },+ { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" },+ { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" },+ { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" },+ { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" },+ { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" },+ { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" },+ { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" },+ { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" },+ { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" },+ { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" },+ { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" },+ { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" },+ { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" },+ { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" },+ { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" },+ { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" },+ { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" },+ { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" },+ { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" },+ { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" },+ { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" },+ { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" },+ { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" },+ { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" },+ { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" },+ { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" },+ { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" },+ { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" },+ { url = "https://files.pythonhosted.org/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809, upload-time = "2025-07-26T12:02:52.74Z" },+ { url = "https://files.pythonhosted.org/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593, upload-time = "2025-07-26T12:02:54.037Z" },+ { url = "https://files.pythonhosted.org/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202, upload-time = "2025-07-26T12:02:55.947Z" },+ { url = "https://files.pythonhosted.org/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207, upload-time = "2025-07-26T12:02:57.468Z" },+ { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload-time = "2025-07-26T12:02:58.801Z" },][[package]]name = "cv2-enumerate-cameras"-version = "1.3.0"+version = "1.3.3"source = { registry = "https://pypi.org/simple" }dependencies = [- { name = "pyobjc-framework-avfoundation", marker = "platform_system == 'Darwin'" },+ { name = "pyobjc-framework-avfoundation", marker = "sys_platform == 'darwin'" },]-sdist = { url = "https://files.pythonhosted.org/packages/71/cf/a6eb5fa54d7dfc87c93a6161aef57527c6ef4d8239be7cef10d13fb9efd6/cv2_enumerate_cameras-1.3.0.tar.gz", hash = "sha256:795d8005b0e92ca117e1b8c4849c752edb39b7e2a1818b2d7ac4463aa26caac1", size = 12455 }+sdist = { url = "https://files.pythonhosted.org/packages/88/40/6208e5ef9a0e46e9acc233c00a1b30728ca3b03b429e751c59e4d9cf5c8b/cv2_enumerate_cameras-1.3.3.tar.gz", hash = "sha256:cc09429e3fd4a2ea3449bbc0ee12420666aee6705d80a36f2235503d90fff3a2", size = 12901, upload-time = "2026-01-16T02:39:47.614Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/3c/38/cc570b8579a2be52d0a3f6dba7afad536bc6d41cfc44108727ef7d8b185a/cv2_enumerate_cameras-1.3.0-cp32-abi3-win32.whl", hash = "sha256:bd24be3c2df42b88da59e9f6029b97484fc8468678a2be3900aa717835c40f6a", size = 20406 },- { url = "https://files.pythonhosted.org/packages/9d/ef/0a6e095462e90d12358ef68653c7ea4d86dd6f5dd8f433279ecb5745e9ca/cv2_enumerate_cameras-1.3.0-cp32-abi3-win_amd64.whl", hash = "sha256:ef892cc7d92dec3ad0f696fa592a9d5461e593698048f84e877353cffcfc486f", size = 21296 },- { url = "https://files.pythonhosted.org/packages/7e/d5/6a6b74c92b6901d7077eb67284010354d90762702ed3451ea5d6297ef692/cv2_enumerate_cameras-1.3.0-py3-none-any.whl", hash = "sha256:7a67d8cc98fd112c3df51ff699c6953884e96088ced2ee05191bdeaaa2e1e847", size = 11571 },+ { url = "https://files.pythonhosted.org/packages/38/a9/7395194e0a7ad25e14669fd499a5bf062cb9ae3dcba4d4fca8dd398b4061/cv2_enumerate_cameras-1.3.3-cp32-abi3-win32.whl", hash = "sha256:700d5d4283eb630e74d0a9e4829b9f5a3e373c3ce9a2e5bbed7959eb5bb31246", size = 20879, upload-time = "2026-01-16T02:39:43.82Z" },+ { url = "https://files.pythonhosted.org/packages/1a/e8/197478c59e66ace7b41cbe6a5ce9cbbea42dfe6a0afba3d4dcc5d4b59df4/cv2_enumerate_cameras-1.3.3-cp32-abi3-win_amd64.whl", hash = "sha256:fb4c9cf9d3f9d1bc0e648943f6683d5dd0228c93d6ed11aae471500701009dee", size = 21768, upload-time = "2026-01-16T02:39:45.1Z" },+ { url = "https://files.pythonhosted.org/packages/98/b1/183463b131f6fb459186fd060ab1761aa8230f52417efc827d335c72df54/cv2_enumerate_cameras-1.3.3-py3-none-any.whl", hash = "sha256:f83c7329d85462bc27d805aa25a3cde73aa66d7e28e2f5b6cb425ccc84c965d0", size = 12043, upload-time = "2026-01-16T02:39:46.184Z" },][[package]]name = "cycler"version = "0.12.1"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615 }+sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321 },+ { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" },][[package]]name = "fastapi"-version = "0.121.2"+version = "0.129.0"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "annotated-doc" },{ name = "pydantic" },{ name = "starlette" },{ name = "typing-extensions" },+ { name = "typing-inspection" },]-sdist = { url = "https://files.pythonhosted.org/packages/fb/48/f08f264da34cf160db82c62ffb335e838b1fc16cbcc905f474c7d4c815db/fastapi-0.121.2.tar.gz", hash = "sha256:ca8e932b2b823ec1721c641e3669472c855ad9564a2854c9899d904c2848b8b9", size = 342944 }+sdist = { url = "https://files.pythonhosted.org/packages/48/47/75f6bea02e797abff1bca968d5997793898032d9923c1935ae2efdece642/fastapi-0.129.0.tar.gz", hash = "sha256:61315cebd2e65df5f97ec298c888f9de30430dd0612d59d6480beafbc10655af", size = 375450, upload-time = "2026-02-12T13:54:52.541Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/eb/23/dfb161e91db7c92727db505dc72a384ee79681fe0603f706f9f9f52c2901/fastapi-0.121.2-py3-none-any.whl", hash = "sha256:f2d80b49a86a846b70cc3a03eb5ea6ad2939298bf6a7fe377aa9cd3dd079d358", size = 109201 },+ { url = "https://files.pythonhosted.org/packages/9e/dd/d0ee25348ac58245ee9f90b6f3cbb666bf01f69be7e0911f9851bddbda16/fastapi-0.129.0-py3-none-any.whl", hash = "sha256:b4946880e48f462692b31c083be0432275cbfb6e2274566b1be91479cc1a84ec", size = 102950, upload-time = "2026-02-12T13:54:54.528Z" },][[package]]name = "flatbuffers"-version = "25.9.23"+version = "25.12.19"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/9d/1f/3ee70b0a55137442038f2a33469cc5fddd7e0ad2abf83d7497c18a2b6923/flatbuffers-25.9.23.tar.gz", hash = "sha256:676f9fa62750bb50cf531b42a0a2a118ad8f7f797a511eda12881c016f093b12", size = 22067 }wheels = [- { url = "https://files.pythonhosted.org/packages/ee/1b/00a78aa2e8fbd63f9af08c9c19e6deb3d5d66b4dda677a0f61654680ee89/flatbuffers-25.9.23-py2.py3-none-any.whl", hash = "sha256:255538574d6cb6d0a79a17ec8bc0d30985913b87513a01cce8bcdb6b4c44d0e2", size = 30869 },+ { url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", hash = "sha256:7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4", size = 26661, upload-time = "2025-12-19T23:16:13.622Z" },][[package]]name = "fonttools"-version = "4.60.1"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/4b/42/97a13e47a1e51a5a7142475bbcf5107fe3a68fc34aef331c897d5fb98ad0/fonttools-4.60.1.tar.gz", hash = "sha256:ef00af0439ebfee806b25f24c8f92109157ff3fac5731dc7867957812e87b8d9", size = 3559823 }-wheels = [- { url = "https://files.pythonhosted.org/packages/ea/85/639aa9bface1537e0fb0f643690672dde0695a5bbbc90736bc571b0b1941/fonttools-4.60.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7b4c32e232a71f63a5d00259ca3d88345ce2a43295bb049d21061f338124246f", size = 2831872 },- { url = "https://files.pythonhosted.org/packages/6b/47/3c63158459c95093be9618794acb1067b3f4d30dcc5c3e8114b70e67a092/fonttools-4.60.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3630e86c484263eaac71d117085d509cbcf7b18f677906824e4bace598fb70d2", size = 2356990 },- { url = "https://files.pythonhosted.org/packages/94/dd/1934b537c86fcf99f9761823f1fc37a98fbd54568e8e613f29a90fed95a9/fonttools-4.60.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5c1015318e4fec75dd4943ad5f6a206d9727adf97410d58b7e32ab644a807914", size = 5042189 },- { url = "https://files.pythonhosted.org/packages/d2/d2/9f4e4c4374dd1daa8367784e1bd910f18ba886db1d6b825b12edf6db3edc/fonttools-4.60.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e6c58beb17380f7c2ea181ea11e7db8c0ceb474c9dd45f48e71e2cb577d146a1", size = 4978683 },- { url = "https://files.pythonhosted.org/packages/cc/c4/0fb2dfd1ecbe9a07954cc13414713ed1eab17b1c0214ef07fc93df234a47/fonttools-4.60.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ec3681a0cb34c255d76dd9d865a55f260164adb9fa02628415cdc2d43ee2c05d", size = 5021372 },- { url = "https://files.pythonhosted.org/packages/0c/d5/495fc7ae2fab20223cc87179a8f50f40f9a6f821f271ba8301ae12bb580f/fonttools-4.60.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f4b5c37a5f40e4d733d3bbaaef082149bee5a5ea3156a785ff64d949bd1353fa", size = 5132562 },- { url = "https://files.pythonhosted.org/packages/bc/fa/021dab618526323c744e0206b3f5c8596a2e7ae9aa38db5948a131123e83/fonttools-4.60.1-cp311-cp311-win32.whl", hash = "sha256:398447f3d8c0c786cbf1209711e79080a40761eb44b27cdafffb48f52bcec258", size = 2230288 },- { url = "https://files.pythonhosted.org/packages/bb/78/0e1a6d22b427579ea5c8273e1c07def2f325b977faaf60bb7ddc01456cb1/fonttools-4.60.1-cp311-cp311-win_amd64.whl", hash = "sha256:d066ea419f719ed87bc2c99a4a4bfd77c2e5949cb724588b9dd58f3fd90b92bf", size = 2278184 },- { url = "https://files.pythonhosted.org/packages/e3/f7/a10b101b7a6f8836a5adb47f2791f2075d044a6ca123f35985c42edc82d8/fonttools-4.60.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:7b0c6d57ab00dae9529f3faf187f2254ea0aa1e04215cf2f1a8ec277c96661bc", size = 2832953 },- { url = "https://files.pythonhosted.org/packages/ed/fe/7bd094b59c926acf2304d2151354ddbeb74b94812f3dc943c231db09cb41/fonttools-4.60.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:839565cbf14645952d933853e8ade66a463684ed6ed6c9345d0faf1f0e868877", size = 2352706 },- { url = "https://files.pythonhosted.org/packages/c0/ca/4bb48a26ed95a1e7eba175535fe5805887682140ee0a0d10a88e1de84208/fonttools-4.60.1-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8177ec9676ea6e1793c8a084a90b65a9f778771998eb919d05db6d4b1c0b114c", size = 4923716 },- { url = "https://files.pythonhosted.org/packages/b8/9f/2cb82999f686c1d1ddf06f6ae1a9117a880adbec113611cc9d22b2fdd465/fonttools-4.60.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:996a4d1834524adbb423385d5a629b868ef9d774670856c63c9a0408a3063401", size = 4968175 },- { url = "https://files.pythonhosted.org/packages/18/79/be569699e37d166b78e6218f2cde8c550204f2505038cdd83b42edc469b9/fonttools-4.60.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a46b2f450bc79e06ef3b6394f0c68660529ed51692606ad7f953fc2e448bc903", size = 4911031 },- { url = "https://files.pythonhosted.org/packages/cc/9f/89411cc116effaec5260ad519162f64f9c150e5522a27cbb05eb62d0c05b/fonttools-4.60.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6ec722ee589e89a89f5b7574f5c45604030aa6ae24cb2c751e2707193b466fed", size = 5062966 },- { url = "https://files.pythonhosted.org/packages/62/a1/f888221934b5731d46cb9991c7a71f30cb1f97c0ef5fcf37f8da8fce6c8e/fonttools-4.60.1-cp312-cp312-win32.whl", hash = "sha256:b2cf105cee600d2de04ca3cfa1f74f1127f8455b71dbad02b9da6ec266e116d6", size = 2218750 },- { url = "https://files.pythonhosted.org/packages/88/8f/a55b5550cd33cd1028601df41acd057d4be20efa5c958f417b0c0613924d/fonttools-4.60.1-cp312-cp312-win_amd64.whl", hash = "sha256:992775c9fbe2cf794786fa0ffca7f09f564ba3499b8fe9f2f80bd7197db60383", size = 2267026 },- { url = "https://files.pythonhosted.org/packages/7c/5b/cdd2c612277b7ac7ec8c0c9bc41812c43dc7b2d5f2b0897e15fdf5a1f915/fonttools-4.60.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6f68576bb4bbf6060c7ab047b1574a1ebe5c50a17de62830079967b211059ebb", size = 2825777 },- { url = "https://files.pythonhosted.org/packages/d6/8a/de9cc0540f542963ba5e8f3a1f6ad48fa211badc3177783b9d5cadf79b5d/fonttools-4.60.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:eedacb5c5d22b7097482fa834bda0dafa3d914a4e829ec83cdea2a01f8c813c4", size = 2348080 },- { url = "https://files.pythonhosted.org/packages/2d/8b/371ab3cec97ee3fe1126b3406b7abd60c8fec8975fd79a3c75cdea0c3d83/fonttools-4.60.1-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b33a7884fabd72bdf5f910d0cf46be50dce86a0362a65cfc746a4168c67eb96c", size = 4903082 },- { url = "https://files.pythonhosted.org/packages/04/05/06b1455e4bc653fcb2117ac3ef5fa3a8a14919b93c60742d04440605d058/fonttools-4.60.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2409d5fb7b55fd70f715e6d34e7a6e4f7511b8ad29a49d6df225ee76da76dd77", size = 4960125 },- { url = "https://files.pythonhosted.org/packages/8e/37/f3b840fcb2666f6cb97038793606bdd83488dca2d0b0fc542ccc20afa668/fonttools-4.60.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c8651e0d4b3bdeda6602b85fdc2abbefc1b41e573ecb37b6779c4ca50753a199", size = 4901454 },- { url = "https://files.pythonhosted.org/packages/fd/9e/eb76f77e82f8d4a46420aadff12cec6237751b0fb9ef1de373186dcffb5f/fonttools-4.60.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:145daa14bf24824b677b9357c5e44fd8895c2a8f53596e1b9ea3496081dc692c", size = 5044495 },- { url = "https://files.pythonhosted.org/packages/f8/b3/cede8f8235d42ff7ae891bae8d619d02c8ac9fd0cfc450c5927a6200c70d/fonttools-4.60.1-cp313-cp313-win32.whl", hash = "sha256:2299df884c11162617a66b7c316957d74a18e3758c0274762d2cc87df7bc0272", size = 2217028 },- { url = "https://files.pythonhosted.org/packages/75/4d/b022c1577807ce8b31ffe055306ec13a866f2337ecee96e75b24b9b753ea/fonttools-4.60.1-cp313-cp313-win_amd64.whl", hash = "sha256:a3db56f153bd4c5c2b619ab02c5db5192e222150ce5a1bc10f16164714bc39ac", size = 2266200 },- { url = "https://files.pythonhosted.org/packages/9a/83/752ca11c1aa9a899b793a130f2e466b79ea0cf7279c8d79c178fc954a07b/fonttools-4.60.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:a884aef09d45ba1206712c7dbda5829562d3fea7726935d3289d343232ecb0d3", size = 2822830 },- { url = "https://files.pythonhosted.org/packages/57/17/bbeab391100331950a96ce55cfbbff27d781c1b85ebafb4167eae50d9fe3/fonttools-4.60.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8a44788d9d91df72d1a5eac49b31aeb887a5f4aab761b4cffc4196c74907ea85", size = 2345524 },- { url = "https://files.pythonhosted.org/packages/3d/2e/d4831caa96d85a84dd0da1d9f90d81cec081f551e0ea216df684092c6c97/fonttools-4.60.1-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e852d9dda9f93ad3651ae1e3bb770eac544ec93c3807888798eccddf84596537", size = 4843490 },- { url = "https://files.pythonhosted.org/packages/49/13/5e2ea7c7a101b6fc3941be65307ef8df92cbbfa6ec4804032baf1893b434/fonttools-4.60.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:154cb6ee417e417bf5f7c42fe25858c9140c26f647c7347c06f0cc2d47eff003", size = 4944184 },- { url = "https://files.pythonhosted.org/packages/0c/2b/cf9603551c525b73fc47c52ee0b82a891579a93d9651ed694e4e2cd08bb8/fonttools-4.60.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5664fd1a9ea7f244487ac8f10340c4e37664675e8667d6fee420766e0fb3cf08", size = 4890218 },- { url = "https://files.pythonhosted.org/packages/fd/2f/933d2352422e25f2376aae74f79eaa882a50fb3bfef3c0d4f50501267101/fonttools-4.60.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:583b7f8e3c49486e4d489ad1deacfb8d5be54a8ef34d6df824f6a171f8511d99", size = 4999324 },- { url = "https://files.pythonhosted.org/packages/38/99/234594c0391221f66216bc2c886923513b3399a148defaccf81dc3be6560/fonttools-4.60.1-cp314-cp314-win32.whl", hash = "sha256:66929e2ea2810c6533a5184f938502cfdaea4bc3efb7130d8cc02e1c1b4108d6", size = 2220861 },- { url = "https://files.pythonhosted.org/packages/3e/1d/edb5b23726dde50fc4068e1493e4fc7658eeefcaf75d4c5ffce067d07ae5/fonttools-4.60.1-cp314-cp314-win_amd64.whl", hash = "sha256:f3d5be054c461d6a2268831f04091dc82753176f6ea06dc6047a5e168265a987", size = 2270934 },- { url = "https://files.pythonhosted.org/packages/fb/da/1392aaa2170adc7071fe7f9cfd181a5684a7afcde605aebddf1fb4d76df5/fonttools-4.60.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:b6379e7546ba4ae4b18f8ae2b9bc5960936007a1c0e30b342f662577e8bc3299", size = 2894340 },- { url = "https://files.pythonhosted.org/packages/bf/a7/3b9f16e010d536ce567058b931a20b590d8f3177b2eda09edd92e392375d/fonttools-4.60.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9d0ced62b59e0430b3690dbc5373df1c2aa7585e9a8ce38eff87f0fd993c5b01", size = 2375073 },- { url = "https://files.pythonhosted.org/packages/9b/b5/e9bcf51980f98e59bb5bb7c382a63c6f6cac0eec5f67de6d8f2322382065/fonttools-4.60.1-cp314-cp314t-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:875cb7764708b3132637f6c5fb385b16eeba0f7ac9fa45a69d35e09b47045801", size = 4849758 },- { url = "https://files.pythonhosted.org/packages/e3/dc/1d2cf7d1cba82264b2f8385db3f5960e3d8ce756b4dc65b700d2c496f7e9/fonttools-4.60.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a184b2ea57b13680ab6d5fbde99ccef152c95c06746cb7718c583abd8f945ccc", size = 5085598 },- { url = "https://files.pythonhosted.org/packages/5d/4d/279e28ba87fb20e0c69baf72b60bbf1c4d873af1476806a7b5f2b7fac1ff/fonttools-4.60.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:026290e4ec76583881763fac284aca67365e0be9f13a7fb137257096114cb3bc", size = 4957603 },- { url = "https://files.pythonhosted.org/packages/78/d4/ff19976305e0c05aa3340c805475abb00224c954d3c65e82c0a69633d55d/fonttools-4.60.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f0e8817c7d1a0c2eedebf57ef9a9896f3ea23324769a9a2061a80fe8852705ed", size = 4974184 },- { url = "https://files.pythonhosted.org/packages/63/22/8553ff6166f5cd21cfaa115aaacaa0dc73b91c079a8cfd54a482cbc0f4f5/fonttools-4.60.1-cp314-cp314t-win32.whl", hash = "sha256:1410155d0e764a4615774e5c2c6fc516259fe3eca5882f034eb9bfdbee056259", size = 2282241 },- { url = "https://files.pythonhosted.org/packages/8a/cb/fa7b4d148e11d5a72761a22e595344133e83a9507a4c231df972e657579b/fonttools-4.60.1-cp314-cp314t-win_amd64.whl", hash = "sha256:022beaea4b73a70295b688f817ddc24ed3e3418b5036ffcd5658141184ef0d0c", size = 2345760 },- { url = "https://files.pythonhosted.org/packages/c7/93/0dd45cd283c32dea1545151d8c3637b4b8c53cdb3a625aeb2885b184d74d/fonttools-4.60.1-py3-none-any.whl", hash = "sha256:906306ac7afe2156fcf0042173d6ebbb05416af70f6b370967b47f8f00103bbb", size = 1143175 },+version = "4.61.1"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/ec/ca/cf17b88a8df95691275a3d77dc0a5ad9907f328ae53acbe6795da1b2f5ed/fonttools-4.61.1.tar.gz", hash = "sha256:6675329885c44657f826ef01d9e4fb33b9158e9d93c537d84ad8399539bc6f69", size = 3565756, upload-time = "2025-12-12T17:31:24.246Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/69/12/bf9f4eaa2fad039356cc627587e30ed008c03f1cebd3034376b5ee8d1d44/fonttools-4.61.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c6604b735bb12fef8e0efd5578c9fb5d3d8532d5001ea13a19cddf295673ee09", size = 2852213, upload-time = "2025-12-12T17:29:46.675Z" },+ { url = "https://files.pythonhosted.org/packages/ac/49/4138d1acb6261499bedde1c07f8c2605d1d8f9d77a151e5507fd3ef084b6/fonttools-4.61.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5ce02f38a754f207f2f06557523cd39a06438ba3aafc0639c477ac409fc64e37", size = 2401689, upload-time = "2025-12-12T17:29:48.769Z" },+ { url = "https://files.pythonhosted.org/packages/e5/fe/e6ce0fe20a40e03aef906af60aa87668696f9e4802fa283627d0b5ed777f/fonttools-4.61.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77efb033d8d7ff233385f30c62c7c79271c8885d5c9657d967ede124671bbdfb", size = 5058809, upload-time = "2025-12-12T17:29:51.701Z" },+ { url = "https://files.pythonhosted.org/packages/79/61/1ca198af22f7dd22c17ab86e9024ed3c06299cfdb08170640e9996d501a0/fonttools-4.61.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:75c1a6dfac6abd407634420c93864a1e274ebc1c7531346d9254c0d8f6ca00f9", size = 5036039, upload-time = "2025-12-12T17:29:53.659Z" },+ { url = "https://files.pythonhosted.org/packages/99/cc/fa1801e408586b5fce4da9f5455af8d770f4fc57391cd5da7256bb364d38/fonttools-4.61.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0de30bfe7745c0d1ffa2b0b7048fb7123ad0d71107e10ee090fa0b16b9452e87", size = 5034714, upload-time = "2025-12-12T17:29:55.592Z" },+ { url = "https://files.pythonhosted.org/packages/bf/aa/b7aeafe65adb1b0a925f8f25725e09f078c635bc22754f3fecb7456955b0/fonttools-4.61.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:58b0ee0ab5b1fc9921eccfe11d1435added19d6494dde14e323f25ad2bc30c56", size = 5158648, upload-time = "2025-12-12T17:29:57.861Z" },+ { url = "https://files.pythonhosted.org/packages/99/f9/08ea7a38663328881384c6e7777bbefc46fd7d282adfd87a7d2b84ec9d50/fonttools-4.61.1-cp311-cp311-win32.whl", hash = "sha256:f79b168428351d11e10c5aeb61a74e1851ec221081299f4cf56036a95431c43a", size = 2280681, upload-time = "2025-12-12T17:29:59.943Z" },+ { url = "https://files.pythonhosted.org/packages/07/ad/37dd1ae5fa6e01612a1fbb954f0927681f282925a86e86198ccd7b15d515/fonttools-4.61.1-cp311-cp311-win_amd64.whl", hash = "sha256:fe2efccb324948a11dd09d22136fe2ac8a97d6c1347cf0b58a911dcd529f66b7", size = 2331951, upload-time = "2025-12-12T17:30:02.254Z" },+ { url = "https://files.pythonhosted.org/packages/6f/16/7decaa24a1bd3a70c607b2e29f0adc6159f36a7e40eaba59846414765fd4/fonttools-4.61.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f3cb4a569029b9f291f88aafc927dd53683757e640081ca8c412781ea144565e", size = 2851593, upload-time = "2025-12-12T17:30:04.225Z" },+ { url = "https://files.pythonhosted.org/packages/94/98/3c4cb97c64713a8cf499b3245c3bf9a2b8fd16a3e375feff2aed78f96259/fonttools-4.61.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41a7170d042e8c0024703ed13b71893519a1a6d6e18e933e3ec7507a2c26a4b2", size = 2400231, upload-time = "2025-12-12T17:30:06.47Z" },+ { url = "https://files.pythonhosted.org/packages/b7/37/82dbef0f6342eb01f54bca073ac1498433d6ce71e50c3c3282b655733b31/fonttools-4.61.1-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:10d88e55330e092940584774ee5e8a6971b01fc2f4d3466a1d6c158230880796", size = 4954103, upload-time = "2025-12-12T17:30:08.432Z" },+ { url = "https://files.pythonhosted.org/packages/6c/44/f3aeac0fa98e7ad527f479e161aca6c3a1e47bb6996b053d45226fe37bf2/fonttools-4.61.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:15acc09befd16a0fb8a8f62bc147e1a82817542d72184acca9ce6e0aeda9fa6d", size = 5004295, upload-time = "2025-12-12T17:30:10.56Z" },+ { url = "https://files.pythonhosted.org/packages/14/e8/7424ced75473983b964d09f6747fa09f054a6d656f60e9ac9324cf40c743/fonttools-4.61.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e6bcdf33aec38d16508ce61fd81838f24c83c90a1d1b8c68982857038673d6b8", size = 4944109, upload-time = "2025-12-12T17:30:12.874Z" },+ { url = "https://files.pythonhosted.org/packages/c8/8b/6391b257fa3d0b553d73e778f953a2f0154292a7a7a085e2374b111e5410/fonttools-4.61.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5fade934607a523614726119164ff621e8c30e8fa1ffffbbd358662056ba69f0", size = 5093598, upload-time = "2025-12-12T17:30:15.79Z" },+ { url = "https://files.pythonhosted.org/packages/d9/71/fd2ea96cdc512d92da5678a1c98c267ddd4d8c5130b76d0f7a80f9a9fde8/fonttools-4.61.1-cp312-cp312-win32.whl", hash = "sha256:75da8f28eff26defba42c52986de97b22106cb8f26515b7c22443ebc9c2d3261", size = 2269060, upload-time = "2025-12-12T17:30:18.058Z" },+ { url = "https://files.pythonhosted.org/packages/80/3b/a3e81b71aed5a688e89dfe0e2694b26b78c7d7f39a5ffd8a7d75f54a12a8/fonttools-4.61.1-cp312-cp312-win_amd64.whl", hash = "sha256:497c31ce314219888c0e2fce5ad9178ca83fe5230b01a5006726cdf3ac9f24d9", size = 2319078, upload-time = "2025-12-12T17:30:22.862Z" },+ { url = "https://files.pythonhosted.org/packages/4b/cf/00ba28b0990982530addb8dc3e9e6f2fa9cb5c20df2abdda7baa755e8fe1/fonttools-4.61.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8c56c488ab471628ff3bfa80964372fc13504ece601e0d97a78ee74126b2045c", size = 2846454, upload-time = "2025-12-12T17:30:24.938Z" },+ { url = "https://files.pythonhosted.org/packages/5a/ca/468c9a8446a2103ae645d14fee3f610567b7042aba85031c1c65e3ef7471/fonttools-4.61.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dc492779501fa723b04d0ab1f5be046797fee17d27700476edc7ee9ae535a61e", size = 2398191, upload-time = "2025-12-12T17:30:27.343Z" },+ { url = "https://files.pythonhosted.org/packages/a3/4b/d67eedaed19def5967fade3297fed8161b25ba94699efc124b14fb68cdbc/fonttools-4.61.1-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:64102ca87e84261419c3747a0d20f396eb024bdbeb04c2bfb37e2891f5fadcb5", size = 4928410, upload-time = "2025-12-12T17:30:29.771Z" },+ { url = "https://files.pythonhosted.org/packages/b0/8d/6fb3494dfe61a46258cd93d979cf4725ded4eb46c2a4ca35e4490d84daea/fonttools-4.61.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c1b526c8d3f615a7b1867f38a9410849c8f4aef078535742198e942fba0e9bd", size = 4984460, upload-time = "2025-12-12T17:30:32.073Z" },+ { url = "https://files.pythonhosted.org/packages/f7/f1/a47f1d30b3dc00d75e7af762652d4cbc3dff5c2697a0dbd5203c81afd9c3/fonttools-4.61.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:41ed4b5ec103bd306bb68f81dc166e77409e5209443e5773cb4ed837bcc9b0d3", size = 4925800, upload-time = "2025-12-12T17:30:34.339Z" },+ { url = "https://files.pythonhosted.org/packages/a7/01/e6ae64a0981076e8a66906fab01539799546181e32a37a0257b77e4aa88b/fonttools-4.61.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b501c862d4901792adaec7c25b1ecc749e2662543f68bb194c42ba18d6eec98d", size = 5067859, upload-time = "2025-12-12T17:30:36.593Z" },+ { url = "https://files.pythonhosted.org/packages/73/aa/28e40b8d6809a9b5075350a86779163f074d2b617c15d22343fce81918db/fonttools-4.61.1-cp313-cp313-win32.whl", hash = "sha256:4d7092bb38c53bbc78e9255a59158b150bcdc115a1e3b3ce0b5f267dc35dd63c", size = 2267821, upload-time = "2025-12-12T17:30:38.478Z" },+ { url = "https://files.pythonhosted.org/packages/1a/59/453c06d1d83dc0951b69ef692d6b9f1846680342927df54e9a1ca91c6f90/fonttools-4.61.1-cp313-cp313-win_amd64.whl", hash = "sha256:21e7c8d76f62ab13c9472ccf74515ca5b9a761d1bde3265152a6dc58700d895b", size = 2318169, upload-time = "2025-12-12T17:30:40.951Z" },+ { url = "https://files.pythonhosted.org/packages/32/8f/4e7bf82c0cbb738d3c2206c920ca34ca74ef9dabde779030145d28665104/fonttools-4.61.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fff4f534200a04b4a36e7ae3cb74493afe807b517a09e99cb4faa89a34ed6ecd", size = 2846094, upload-time = "2025-12-12T17:30:43.511Z" },+ { url = "https://files.pythonhosted.org/packages/71/09/d44e45d0a4f3a651f23a1e9d42de43bc643cce2971b19e784cc67d823676/fonttools-4.61.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d9203500f7c63545b4ce3799319fe4d9feb1a1b89b28d3cb5abd11b9dd64147e", size = 2396589, upload-time = "2025-12-12T17:30:45.681Z" },+ { url = "https://files.pythonhosted.org/packages/89/18/58c64cafcf8eb677a99ef593121f719e6dcbdb7d1c594ae5a10d4997ca8a/fonttools-4.61.1-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fa646ecec9528bef693415c79a86e733c70a4965dd938e9a226b0fc64c9d2e6c", size = 4877892, upload-time = "2025-12-12T17:30:47.709Z" },+ { url = "https://files.pythonhosted.org/packages/8a/ec/9e6b38c7ba1e09eb51db849d5450f4c05b7e78481f662c3b79dbde6f3d04/fonttools-4.61.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:11f35ad7805edba3aac1a3710d104592df59f4b957e30108ae0ba6c10b11dd75", size = 4972884, upload-time = "2025-12-12T17:30:49.656Z" },+ { url = "https://files.pythonhosted.org/packages/5e/87/b5339da8e0256734ba0dbbf5b6cdebb1dd79b01dc8c270989b7bcd465541/fonttools-4.61.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b931ae8f62db78861b0ff1ac017851764602288575d65b8e8ff1963fed419063", size = 4924405, upload-time = "2025-12-12T17:30:51.735Z" },+ { url = "https://files.pythonhosted.org/packages/0b/47/e3409f1e1e69c073a3a6fd8cb886eb18c0bae0ee13db2c8d5e7f8495e8b7/fonttools-4.61.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b148b56f5de675ee16d45e769e69f87623a4944f7443850bf9a9376e628a89d2", size = 5035553, upload-time = "2025-12-12T17:30:54.823Z" },+ { url = "https://files.pythonhosted.org/packages/bf/b6/1f6600161b1073a984294c6c031e1a56ebf95b6164249eecf30012bb2e38/fonttools-4.61.1-cp314-cp314-win32.whl", hash = "sha256:9b666a475a65f4e839d3d10473fad6d47e0a9db14a2f4a224029c5bfde58ad2c", size = 2271915, upload-time = "2025-12-12T17:30:57.913Z" },+ { url = "https://files.pythonhosted.org/packages/52/7b/91e7b01e37cc8eb0e1f770d08305b3655e4f002fc160fb82b3390eabacf5/fonttools-4.61.1-cp314-cp314-win_amd64.whl", hash = "sha256:4f5686e1fe5fce75d82d93c47a438a25bf0d1319d2843a926f741140b2b16e0c", size = 2323487, upload-time = "2025-12-12T17:30:59.804Z" },+ { url = "https://files.pythonhosted.org/packages/39/5c/908ad78e46c61c3e3ed70c3b58ff82ab48437faf84ec84f109592cabbd9f/fonttools-4.61.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:e76ce097e3c57c4bcb67c5aa24a0ecdbd9f74ea9219997a707a4061fbe2707aa", size = 2929571, upload-time = "2025-12-12T17:31:02.574Z" },+ { url = "https://files.pythonhosted.org/packages/bd/41/975804132c6dea64cdbfbaa59f3518a21c137a10cccf962805b301ac6ab2/fonttools-4.61.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:9cfef3ab326780c04d6646f68d4b4742aae222e8b8ea1d627c74e38afcbc9d91", size = 2435317, upload-time = "2025-12-12T17:31:04.974Z" },+ { url = "https://files.pythonhosted.org/packages/b0/5a/aef2a0a8daf1ebaae4cfd83f84186d4a72ee08fd6a8451289fcd03ffa8a4/fonttools-4.61.1-cp314-cp314t-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a75c301f96db737e1c5ed5fd7d77d9c34466de16095a266509e13da09751bd19", size = 4882124, upload-time = "2025-12-12T17:31:07.456Z" },+ { url = "https://files.pythonhosted.org/packages/80/33/d6db3485b645b81cea538c9d1c9219d5805f0877fda18777add4671c5240/fonttools-4.61.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:91669ccac46bbc1d09e9273546181919064e8df73488ea087dcac3e2968df9ba", size = 5100391, upload-time = "2025-12-12T17:31:09.732Z" },+ { url = "https://files.pythonhosted.org/packages/6c/d6/675ba631454043c75fcf76f0ca5463eac8eb0666ea1d7badae5fea001155/fonttools-4.61.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c33ab3ca9d3ccd581d58e989d67554e42d8d4ded94ab3ade3508455fe70e65f7", size = 4978800, upload-time = "2025-12-12T17:31:11.681Z" },+ { url = "https://files.pythonhosted.org/packages/7f/33/d3ec753d547a8d2bdaedd390d4a814e8d5b45a093d558f025c6b990b554c/fonttools-4.61.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:664c5a68ec406f6b1547946683008576ef8b38275608e1cee6c061828171c118", size = 5006426, upload-time = "2025-12-12T17:31:13.764Z" },+ { url = "https://files.pythonhosted.org/packages/b4/40/cc11f378b561a67bea850ab50063366a0d1dd3f6d0a30ce0f874b0ad5664/fonttools-4.61.1-cp314-cp314t-win32.whl", hash = "sha256:aed04cabe26f30c1647ef0e8fbb207516fd40fe9472e9439695f5c6998e60ac5", size = 2335377, upload-time = "2025-12-12T17:31:16.49Z" },+ { url = "https://files.pythonhosted.org/packages/e4/ff/c9a2b66b39f8628531ea58b320d66d951267c98c6a38684daa8f50fb02f8/fonttools-4.61.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2180f14c141d2f0f3da43f3a81bc8aa4684860f6b0e6f9e165a4831f24e6a23b", size = 2400613, upload-time = "2025-12-12T17:31:18.769Z" },+ { url = "https://files.pythonhosted.org/packages/c7/4e/ce75a57ff3aebf6fc1f4e9d508b8e5810618a33d900ad6c19eb30b290b97/fonttools-4.61.1-py3-none-any.whl", hash = "sha256:17d2bf5d541add43822bcf0c43d7d847b160c9bb01d15d5007d84e2217aaa371", size = 1148996, upload-time = "2025-12-12T17:31:21.03Z" },][[package]]@@ -482,12 +494,21 @@ dependencies = [{ name = "skelly-viewer" },{ name = "skellycam" },{ name = "skellyforge" },- { name = "skellytracker" },+ { name = "skellytracker", extra = ["mediapipe"] },+ { name = "tomli-w" },][package.dev-dependencies]dev = [{ name = "bumpver" },+ { name = "httpx" },+ { name = "nuitka" },+ { name = "pip-tools" },+ { name = "poethepoet" },+ { name = "pyinstaller" },+ { name = "pytest" },+ { name = "pytest-asyncio" },+ { name = "ruff" },][package.metadata]@@ -503,21 +524,32 @@ requires-dist = [{ name = "requests", specifier = ">=2.32.3" },{ name = "scikit-learn", specifier = ">=1.7.2" },{ name = "skelly-viewer" },- { name = "skellycam", git = "https://github.com/freemocap/skellycam?branch=jon%2Fdevelopment" },- { name = "skellyforge", git = "https://github.com/freemocap/skellyforge?branch=jon%2Fdevelopment" },- { name = "skellytracker", git = "https://github.com/freemocap/skellytracker?branch=jon%2Fdevelopment" },+ { name = "skellycam", git = "https://github.com/freemocap/skellycam?branch=development" },+ { name = "skellyforge", git = "https://github.com/freemocap/skellyforge?branch=development" },+ { name = "skellytracker", extras = ["mediapipe"], git = "https://github.com/freemocap/skellytracker?branch=development" },+ { name = "tomli-w", specifier = ">=1.2.0" },][package.metadata.requires-dev]-dev = [{ name = "bumpver" }]+dev = [+ { name = "bumpver" },+ { name = "httpx", specifier = ">=0.28.0" },+ { name = "nuitka", specifier = ">=2.7.7" },+ { name = "pip-tools" },+ { name = "poethepoet", specifier = ">=0.32.0" },+ { name = "pyinstaller", specifier = ">=6.15.0" },+ { name = "pytest", specifier = ">=8.4.0" },+ { name = "pytest-asyncio", specifier = ">=1.0.0" },+ { name = "ruff", specifier = ">=0.9.0" },+][[package]]name = "h11"version = "0.16.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250 }+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515 },+ { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },][[package]]@@ -528,9 +560,9 @@ dependencies = [{ name = "certifi" },{ name = "h11" },]-sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484 }+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784 },+ { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },][[package]]@@ -543,300 +575,184 @@ dependencies = [{ name = "httpcore" },{ name = "idna" },]-sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406 }+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517 },+ { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },][[package]]name = "idna"version = "3.11"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582 }+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008 },+ { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },][[package]]name = "iniconfig"version = "2.3.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503 }-wheels = [- { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484 },-]--[[package]]-name = "jax"-version = "0.4.29"-source = { registry = "https://pypi.org/simple" }-resolution-markers = [- "python_full_version >= '3.13' and platform_system == 'Darwin'",- "python_full_version >= '3.13' and platform_machine == 'aarch64' and platform_system == 'Linux'",- "(python_full_version >= '3.13' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version >= '3.13' and platform_system != 'Darwin' and platform_system != 'Linux')",-]-dependencies = [- { name = "ml-dtypes", version = "0.4.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },- { name = "numpy", marker = "python_full_version >= '3.13'" },- { name = "opt-einsum", marker = "python_full_version >= '3.13'" },- { name = "scipy", marker = "python_full_version >= '3.13'" },-]-sdist = { url = "https://files.pythonhosted.org/packages/27/ab/330b9f80b2a5fbde953d0c1f3eae94cbb9852fa06dc2372ff90c5cd6c837/jax-0.4.29.tar.gz", hash = "sha256:12904571eaefddcdc8c3b8d4936482b783d5a216e99ef5adcd3522fdfb4fc186", size = 1698327 }-wheels = [- { url = "https://files.pythonhosted.org/packages/5b/ad/e05dfb934ab7ac55c6bb2e6f2b8de8641bcaec0a35078c3e91f645cd43ad/jax-0.4.29-py3-none-any.whl", hash = "sha256:cfdc594d133d7dfba2ec19bc10742ffaa0e8827ead29be00d3ec4215a3f7892e", size = 1990921 },-]--[[package]]-name = "jax"-version = "0.7.1"-source = { registry = "https://pypi.org/simple" }-resolution-markers = [- "python_full_version < '3.12' and platform_system == 'Darwin'",- "python_full_version < '3.12' and platform_machine == 'aarch64' and platform_system == 'Linux'",- "(python_full_version < '3.12' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version < '3.12' and platform_system != 'Darwin' and platform_system != 'Linux')",- "python_full_version == '3.12.*' and platform_system == 'Darwin'",- "python_full_version == '3.12.*' and platform_machine == 'aarch64' and platform_system == 'Linux'",- "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version == '3.12.*' and platform_system != 'Darwin' and platform_system != 'Linux')",-]-dependencies = [- { name = "jaxlib", version = "0.7.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },- { name = "ml-dtypes", version = "0.5.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },- { name = "numpy", marker = "python_full_version < '3.13'" },- { name = "opt-einsum", marker = "python_full_version < '3.13'" },- { name = "scipy", marker = "python_full_version < '3.13'" },-]-sdist = { url = "https://files.pythonhosted.org/packages/bc/e8/b393ee314d3b042bd66b986d38e52f4e6046590399d916381265c20467d3/jax-0.7.1.tar.gz", hash = "sha256:118f56338c503361d2791f069d24339d8d44a8db442ed851d2e591222fb7a56d", size = 2428411 }+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/83/81/793d78c91b0546b3b1f08e55fdd97437174171cd7d70e46098f1a4d94b7b/jax-0.7.1-py3-none-any.whl", hash = "sha256:056e576e0e58465506125699f48111ac8891cce4c9ebf034704c42b219dfd4a6", size = 2827341 },-]--[[package]]-name = "jaxlib"-version = "0.6.1"-source = { registry = "https://pypi.org/simple" }-resolution-markers = [- "python_full_version >= '3.13' and platform_system == 'Darwin'",- "python_full_version >= '3.13' and platform_machine == 'aarch64' and platform_system == 'Linux'",- "(python_full_version >= '3.13' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version >= '3.13' and platform_system != 'Darwin' and platform_system != 'Linux')",-]-dependencies = [- { name = "ml-dtypes", version = "0.4.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },- { name = "numpy", marker = "python_full_version >= '3.13'" },- { name = "scipy", marker = "python_full_version >= '3.13'" },-]-wheels = [- { url = "https://files.pythonhosted.org/packages/80/62/a3ceb8f8dedb43b4f672b9f2f766029a9f94a016ee6d6974894ab0420eb0/jaxlib-0.6.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:02bac5153389f01616516a9fd1dcd6038d23ee50681dac14e4ddbc43ccb3133a", size = 53771693 },- { url = "https://files.pythonhosted.org/packages/7d/40/eae51c403e98353e44aa1eaebf9522baf0488bccfc6f91dfe9d4f448c2ef/jaxlib-0.6.1-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:5a90ee7c59b2c00773026fbf918269c7a8676a6a81a34a03af919f7d7bdce9a8", size = 78689747 },- { url = "https://files.pythonhosted.org/packages/6e/6a/94aeafd16d610b09dff8d917b8bdf5f985a6aa2b1a414bc1cfdf5421c09d/jaxlib-0.6.1-cp311-cp311-manylinux2014_x86_64.whl", hash = "sha256:11fcc4b1c741a1e0057f2ffa77d5a82bfe7ee97c3864ed88df67493e789b9173", size = 89050151 },- { url = "https://files.pythonhosted.org/packages/e0/5e/f3aaf20ec803227eeb73ac06e2b451e338240f83fa9fb97fc9faaed1a520/jaxlib-0.6.1-cp311-cp311-win_amd64.whl", hash = "sha256:2168217ec37bf951ca33377d3e0953178ba5cade95f194211d9ab2d53dcd2201", size = 56825361 },- { url = "https://files.pythonhosted.org/packages/83/76/fec2772816bad8ee3f7b450bf3e0927d5e158c45a57b6cd92a48b80bfb1a/jaxlib-0.6.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e14195c23eecd559a61c31027b4172e912e5a50f630320918ffdfae83090ca5a", size = 53787339 },- { url = "https://files.pythonhosted.org/packages/f2/ca/957fdfe2f10477004edca87cd392de21f1d5d3030773601ccd3a0ed0cf72/jaxlib-0.6.1-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:b58c29fe747622b70946ea87823ad39202cc83da3d93a5293b432173b738a868", size = 78695871 },- { url = "https://files.pythonhosted.org/packages/79/7b/bb5e24fc929513e3c310b3054d6588b1b6bbf241b5ca12f6eb3d51458981/jaxlib-0.6.1-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:d039124468565bbf39363b1504c190e6719e6af89a7948dee256f1dee813bb94", size = 89068176 },- { url = "https://files.pythonhosted.org/packages/1b/12/2bc629d530ee1b333edc81a1d68d262bad2f813ce60fdd46e98d48cc8a20/jaxlib-0.6.1-cp312-cp312-win_amd64.whl", hash = "sha256:76d6f65f3153ffb70e20a76b915d4431823cf70a786d86ba1b76a9c5bf66a0a4", size = 56851131 },- { url = "https://files.pythonhosted.org/packages/8a/b8/6d540bd4b05d1fdfdb140772ea337051d16fb22fd6636d1be88a2848a930/jaxlib-0.6.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f4ca75d9d47a2e90099adfede0e9c926b83ef703d349b3289b8c88e861c09e5d", size = 53790062 },- { url = "https://files.pythonhosted.org/packages/61/03/3fde775865a7d972bb9b23f584b0017aa61104ea6ffc32855b3c0297ca63/jaxlib-0.6.1-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:d0c343c51b1052593edb603ddf58cf7f98812b2951ae6c45bd6e93e3e1f2f621", size = 78694596 },- { url = "https://files.pythonhosted.org/packages/59/89/b0a229bf0bd333ef1a5690682deee86f3b38f55613f1423bb2eb26b2d15c/jaxlib-0.6.1-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:e734be70fe3e1fa2a31415362721189d974d10a66b0f5396c84585587d101b15", size = 89067270 },- { url = "https://files.pythonhosted.org/packages/f2/ea/cf861b8971f4362be8948fd0ef61a55866b8cc6f562ae0c9671a9d289f99/jaxlib-0.6.1-cp313-cp313-win_amd64.whl", hash = "sha256:b12c8842b2dfc0770ca3785e183f7bed3fa1c2596c720591dbfbe29a05045108", size = 56850186 },- { url = "https://files.pythonhosted.org/packages/03/46/2495a0e387646d1d702d66aa5fd1675f392e959a7d8790b68dca33a8dad0/jaxlib-0.6.1-cp313-cp313t-manylinux2014_aarch64.whl", hash = "sha256:acfe91eb44c29dbbd1f1f65f9bd66e1aef4483f57ad5e3d645129f3ec9ecde2a", size = 78837195 },- { url = "https://files.pythonhosted.org/packages/f2/d7/dccc6354589ebe6a78f591dbdf15f2ef41c81084e5d051a3d2d1674ecb8f/jaxlib-0.6.1-cp313-cp313t-manylinux2014_x86_64.whl", hash = "sha256:5e4f49113a527bcbac70c9e7074e95d8abfa35c3d67c2fed01f77a7abfd317aa", size = 89194164 },-]--[[package]]-name = "jaxlib"-version = "0.7.1"-source = { registry = "https://pypi.org/simple" }-resolution-markers = [- "python_full_version < '3.12' and platform_system == 'Darwin'",- "python_full_version < '3.12' and platform_machine == 'aarch64' and platform_system == 'Linux'",- "(python_full_version < '3.12' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version < '3.12' and platform_system != 'Darwin' and platform_system != 'Linux')",- "python_full_version == '3.12.*' and platform_system == 'Darwin'",- "python_full_version == '3.12.*' and platform_machine == 'aarch64' and platform_system == 'Linux'",- "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version == '3.12.*' and platform_system != 'Darwin' and platform_system != 'Linux')",-]-dependencies = [- { name = "ml-dtypes", version = "0.5.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },- { name = "numpy", marker = "python_full_version < '3.13'" },- { name = "scipy", marker = "python_full_version < '3.13'" },-]-wheels = [- { url = "https://files.pythonhosted.org/packages/8b/af/5058d545e95f99a54289648f5430cc3c23263dd70a1391e7491f24ed328d/jaxlib-0.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3f32c3e4c167b7327c342e82d3df84079714ea0b43718be871d039999670b3c9", size = 57686934 },- { url = "https://files.pythonhosted.org/packages/e8/77/ef7f6cd03e699da7d9755f88741c29b3015654473fc9d5f906da19edcb47/jaxlib-0.7.1-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:9fb189c3b39470c4394ffcb18b71e47cffc5bf85e8fcb1e33692686b0c3e04dd", size = 85134885 },- { url = "https://files.pythonhosted.org/packages/4d/72/304018d46703f337787f010735f70d17212f86778fcba8bb5cf678f8e460/jaxlib-0.7.1-cp311-cp311-manylinux_2_27_x86_64.whl", hash = "sha256:eaf5f68f53bf4dcb93b6512538547667625588e4f3ccaeef048788fd18d8c0d5", size = 81147868 },- { url = "https://files.pythonhosted.org/packages/f7/b7/0f0df407518691099d659ba6e19db01320dfb58e49d80594eaddd57d77c1/jaxlib-0.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:ab4510fbaeafac6c794ab335f23e71200d824c48f6a0ab20553db8deab8805c5", size = 61185342 },- { url = "https://files.pythonhosted.org/packages/ef/1f/10543d7a3f7e76dd4bbdc77134890ac2f41bc8570c565961464f6320009b/jaxlib-0.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:127c07c727703e5d59f84f655169bec849f4422e52f8546349cecc30a8a13e1d", size = 57682851 },- { url = "https://files.pythonhosted.org/packages/de/4d/76ee71959311fe3da9951aa6f55af8f98eb3572bb322f5a7c89faf7ab933/jaxlib-0.7.1-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:f0f1f52956b8c2518ab000a4d3d8c21be777e1d47f926ba03640e391061a41ee", size = 85133707 },- { url = "https://files.pythonhosted.org/packages/0d/50/e37d02e250f5feb755112ec95b1c012a36d48a99209277267037d100f630/jaxlib-0.7.1-cp312-cp312-manylinux_2_27_x86_64.whl", hash = "sha256:74abd3135797f82440dd3711a35cba16c430d1bba65474b85bb70e41733a52e9", size = 81156916 },- { url = "https://files.pythonhosted.org/packages/5a/97/c6c28dfe57cccffd85512615416024b52dd327d78270204caba9311e71f1/jaxlib-0.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:c4023863b14f280516f24ecb7539b4300a3236ea81ed69ad82595beceed1ba1f", size = 61212445 },- { url = "https://files.pythonhosted.org/packages/35/ad/ab61b9bf72bc2903ee54d02e8d1e1486a4860878712c80c4a52025bfe003/jaxlib-0.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2a27379e5ed29765980ef32d4d77f57dd0e1dd965803ac674554044ac23cd3ec", size = 57681905 },- { url = "https://files.pythonhosted.org/packages/12/e8/fbc318afd21ea7b232ec6a3a1b0138da0d65db1d6f1cea8af458a7d6a482/jaxlib-0.7.1-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:ce6a1ba6019764870c27507aca18e526998ad3ad4bea2dd61e19d0499c3b8b04", size = 85133036 },- { url = "https://files.pythonhosted.org/packages/56/69/209e5b81dd89da84f729a684c126cc3c22bb8d6516f8c968444c7d86050f/jaxlib-0.7.1-cp313-cp313-manylinux_2_27_x86_64.whl", hash = "sha256:b350f519a86eff5a4b1ee014c7faa36585f47f3d63787d1f3e9bdffe9cc41a66", size = 81155944 },- { url = "https://files.pythonhosted.org/packages/95/46/685ecf0fa3c6d844ac33c0dea59601b9cc6b7236d0e4eb52dc3b7f6f52bb/jaxlib-0.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:407347dd5846248ee40db33da26f2b18c7d135249ff06c0271a2e33efd8fb3fe", size = 61213006 },- { url = "https://files.pythonhosted.org/packages/4f/ca/c70e5439eec1abc1a93bad521452dbddeefa68128f256991e6845e9fc56a/jaxlib-0.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:66b33cc15040af5b8d16d3006811eb31372e9f4cfe09393d6cea91795366bfa4", size = 57787598 },- { url = "https://files.pythonhosted.org/packages/1f/54/6d54d6d6a2019cbffa7316de038002b0250568199f2b4138326eb27e3910/jaxlib-0.7.1-cp313-cp313t-manylinux2014_aarch64.whl", hash = "sha256:58558fa29fd7d6342c066f837e58fcba335182837a959affc128660c089702de", size = 85286808 },- { url = "https://files.pythonhosted.org/packages/79/e2/a0ce0ac2aa9b12a83f3bb27c570361017743c5cf82f1044771daa4c865a6/jaxlib-0.7.1-cp313-cp313t-manylinux_2_27_x86_64.whl", hash = "sha256:944f7555960d69f1d1c435fff0a76e4edd6a878fe47fe1781f7a0d63b61072e5", size = 81252495 },- { url = "https://files.pythonhosted.org/packages/7d/e1/9a5317a520aa964944761bf1d050a6a20d0792d9af5005e25804a1ce0e84/jaxlib-0.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:72dd9c3e95457a5a54f00e47ec14863b5e61540b944c0df13bf10c259b4d5d73", size = 57696029 },- { url = "https://files.pythonhosted.org/packages/98/ae/52cb0552b6e1b1008bc68b45ad51091086cccdc1a7e3d32ba9856d7fa879/jaxlib-0.7.1-cp314-cp314-manylinux2014_aarch64.whl", hash = "sha256:023df41212ae4fda869338370f9532bfcd98ccfaee909bb95ea540d6053df547", size = 85146969 },- { url = "https://files.pythonhosted.org/packages/c7/3a/a63b6bd9cac259c22ae324fcb1d5c74e053e8acad23f13ad39ffa6fd11e6/jaxlib-0.7.1-cp314-cp314-manylinux_2_27_x86_64.whl", hash = "sha256:d52817a42c130d0c330f48edcb3a3e455dc984b6ce53f3182c37aa0fe960109b", size = 81167909 },- { url = "https://files.pythonhosted.org/packages/5d/e3/75cc67d24e14279c634ed4c4d501ee62f68d8260aac7d87fd267488aa90a/jaxlib-0.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:38ac46ec17c0a86b428590d04559629357fc6dc3a3c76569f022b982c36fc1af", size = 63566625 },- { url = "https://files.pythonhosted.org/packages/a8/94/f2adf6979a89fcba2ff68b6add47e316bd1274d6ac1284c991d19d8dc2e0/jaxlib-0.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6057a602632bd3299d6c7ffbbb3f1ef2c7573ccbed9eb06cc92042b96e2ca5d4", size = 57787077 },- { url = "https://files.pythonhosted.org/packages/f2/64/e581007dabf29be6d916fb201f1af264edabc3f74097be9f02606eae8836/jaxlib-0.7.1-cp314-cp314t-manylinux2014_aarch64.whl", hash = "sha256:9766817cfa51743a48fac78c087605c30bf1a91caf11371ca8c41261e6f3a0c8", size = 85285337 },- { url = "https://files.pythonhosted.org/packages/ee/0e/2e9e5c82f0b8a5a2be470c5185811ab2d780f2da448339e09f71af06f36a/jaxlib-0.7.1-cp314-cp314t-manylinux_2_27_x86_64.whl", hash = "sha256:1ea54e6182d85b82496fbc58bbe51042bea3ee3e1e0d444b3cff446c245bebd5", size = 81256695 },+ { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },][[package]]name = "joblib"-version = "1.5.2"+version = "1.5.3"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/e8/5d/447af5ea094b9e4c4054f82e223ada074c552335b9b4b2d14bd9b35a67c4/joblib-1.5.2.tar.gz", hash = "sha256:3faa5c39054b2f03ca547da9b2f52fde67c06240c31853f306aea97f13647b55", size = 331077 }+sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", hash = "sha256:8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3", size = 331603, upload-time = "2025-12-15T08:41:46.427Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/1e/e8/685f47e0d754320684db4425a0967f7d3fa70126bffd76110b7009a0090f/joblib-1.5.2-py3-none-any.whl", hash = "sha256:4e1f0bdbb987e6d843c70cf43714cb276623def372df3c22fe5266b2670bc241", size = 308396 },+ { url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", hash = "sha256:5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713", size = 309071, upload-time = "2025-12-15T08:41:44.973Z" },][[package]]name = "kiwisolver"version = "1.4.9"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/5c/3c/85844f1b0feb11ee581ac23fe5fce65cd049a200c1446708cc1b7f922875/kiwisolver-1.4.9.tar.gz", hash = "sha256:c3b22c26c6fd6811b0ae8363b95ca8ce4ea3c202d3d0975b2914310ceb1bcc4d", size = 97564 }-wheels = [- { url = "https://files.pythonhosted.org/packages/6f/ab/c80b0d5a9d8a1a65f4f815f2afff9798b12c3b9f31f1d304dd233dd920e2/kiwisolver-1.4.9-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb14a5da6dc7642b0f3a18f13654847cd8b7a2550e2645a5bda677862b03ba16", size = 124167 },- { url = "https://files.pythonhosted.org/packages/a0/c0/27fe1a68a39cf62472a300e2879ffc13c0538546c359b86f149cc19f6ac3/kiwisolver-1.4.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:39a219e1c81ae3b103643d2aedb90f1ef22650deb266ff12a19e7773f3e5f089", size = 66579 },- { url = "https://files.pythonhosted.org/packages/31/a2/a12a503ac1fd4943c50f9822678e8015a790a13b5490354c68afb8489814/kiwisolver-1.4.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2405a7d98604b87f3fc28b1716783534b1b4b8510d8142adca34ee0bc3c87543", size = 65309 },- { url = "https://files.pythonhosted.org/packages/66/e1/e533435c0be77c3f64040d68d7a657771194a63c279f55573188161e81ca/kiwisolver-1.4.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:dc1ae486f9abcef254b5618dfb4113dd49f94c68e3e027d03cf0143f3f772b61", size = 1435596 },- { url = "https://files.pythonhosted.org/packages/67/1e/51b73c7347f9aabdc7215aa79e8b15299097dc2f8e67dee2b095faca9cb0/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a1f570ce4d62d718dce3f179ee78dac3b545ac16c0c04bb363b7607a949c0d1", size = 1246548 },- { url = "https://files.pythonhosted.org/packages/21/aa/72a1c5d1e430294f2d32adb9542719cfb441b5da368d09d268c7757af46c/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb27e7b78d716c591e88e0a09a2139c6577865d7f2e152488c2cc6257f460872", size = 1263618 },- { url = "https://files.pythonhosted.org/packages/a3/af/db1509a9e79dbf4c260ce0cfa3903ea8945f6240e9e59d1e4deb731b1a40/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:15163165efc2f627eb9687ea5f3a28137217d217ac4024893d753f46bce9de26", size = 1317437 },- { url = "https://files.pythonhosted.org/packages/e0/f2/3ea5ee5d52abacdd12013a94130436e19969fa183faa1e7c7fbc89e9a42f/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bdee92c56a71d2b24c33a7d4c2856bd6419d017e08caa7802d2963870e315028", size = 2195742 },- { url = "https://files.pythonhosted.org/packages/6f/9b/1efdd3013c2d9a2566aa6a337e9923a00590c516add9a1e89a768a3eb2fc/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:412f287c55a6f54b0650bd9b6dce5aceddb95864a1a90c87af16979d37c89771", size = 2290810 },- { url = "https://files.pythonhosted.org/packages/fb/e5/cfdc36109ae4e67361f9bc5b41323648cb24a01b9ade18784657e022e65f/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2c93f00dcba2eea70af2be5f11a830a742fe6b579a1d4e00f47760ef13be247a", size = 2461579 },- { url = "https://files.pythonhosted.org/packages/62/86/b589e5e86c7610842213994cdea5add00960076bef4ae290c5fa68589cac/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f117e1a089d9411663a3207ba874f31be9ac8eaa5b533787024dc07aeb74f464", size = 2268071 },- { url = "https://files.pythonhosted.org/packages/3b/c6/f8df8509fd1eee6c622febe54384a96cfaf4d43bf2ccec7a0cc17e4715c9/kiwisolver-1.4.9-cp311-cp311-win_amd64.whl", hash = "sha256:be6a04e6c79819c9a8c2373317d19a96048e5a3f90bec587787e86a1153883c2", size = 73840 },- { url = "https://files.pythonhosted.org/packages/e2/2d/16e0581daafd147bc11ac53f032a2b45eabac897f42a338d0a13c1e5c436/kiwisolver-1.4.9-cp311-cp311-win_arm64.whl", hash = "sha256:0ae37737256ba2de764ddc12aed4956460277f00c4996d51a197e72f62f5eec7", size = 65159 },- { url = "https://files.pythonhosted.org/packages/86/c9/13573a747838aeb1c76e3267620daa054f4152444d1f3d1a2324b78255b5/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ac5a486ac389dddcc5bef4f365b6ae3ffff2c433324fb38dd35e3fab7c957999", size = 123686 },- { url = "https://files.pythonhosted.org/packages/51/ea/2ecf727927f103ffd1739271ca19c424d0e65ea473fbaeea1c014aea93f6/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f2ba92255faa7309d06fe44c3a4a97efe1c8d640c2a79a5ef728b685762a6fd2", size = 66460 },- { url = "https://files.pythonhosted.org/packages/5b/5a/51f5464373ce2aeb5194508298a508b6f21d3867f499556263c64c621914/kiwisolver-1.4.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a2899935e724dd1074cb568ce7ac0dce28b2cd6ab539c8e001a8578eb106d14", size = 64952 },- { url = "https://files.pythonhosted.org/packages/70/90/6d240beb0f24b74371762873e9b7f499f1e02166a2d9c5801f4dbf8fa12e/kiwisolver-1.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f6008a4919fdbc0b0097089f67a1eb55d950ed7e90ce2cc3e640abadd2757a04", size = 1474756 },- { url = "https://files.pythonhosted.org/packages/12/42/f36816eaf465220f683fb711efdd1bbf7a7005a2473d0e4ed421389bd26c/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:67bb8b474b4181770f926f7b7d2f8c0248cbcb78b660fdd41a47054b28d2a752", size = 1276404 },- { url = "https://files.pythonhosted.org/packages/2e/64/bc2de94800adc830c476dce44e9b40fd0809cddeef1fde9fcf0f73da301f/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2327a4a30d3ee07d2fbe2e7933e8a37c591663b96ce42a00bc67461a87d7df77", size = 1294410 },- { url = "https://files.pythonhosted.org/packages/5f/42/2dc82330a70aa8e55b6d395b11018045e58d0bb00834502bf11509f79091/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a08b491ec91b1d5053ac177afe5290adacf1f0f6307d771ccac5de30592d198", size = 1343631 },- { url = "https://files.pythonhosted.org/packages/22/fd/f4c67a6ed1aab149ec5a8a401c323cee7a1cbe364381bb6c9c0d564e0e20/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8fc5c867c22b828001b6a38d2eaeb88160bf5783c6cb4a5e440efc981ce286d", size = 2224963 },- { url = "https://files.pythonhosted.org/packages/45/aa/76720bd4cb3713314677d9ec94dcc21ced3f1baf4830adde5bb9b2430a5f/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3b3115b2581ea35bb6d1f24a4c90af37e5d9b49dcff267eeed14c3893c5b86ab", size = 2321295 },- { url = "https://files.pythonhosted.org/packages/80/19/d3ec0d9ab711242f56ae0dc2fc5d70e298bb4a1f9dfab44c027668c673a1/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858e4c22fb075920b96a291928cb7dea5644e94c0ee4fcd5af7e865655e4ccf2", size = 2487987 },- { url = "https://files.pythonhosted.org/packages/39/e9/61e4813b2c97e86b6fdbd4dd824bf72d28bcd8d4849b8084a357bc0dd64d/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ed0fecd28cc62c54b262e3736f8bb2512d8dcfdc2bcf08be5f47f96bf405b145", size = 2291817 },- { url = "https://files.pythonhosted.org/packages/a0/41/85d82b0291db7504da3c2defe35c9a8a5c9803a730f297bd823d11d5fb77/kiwisolver-1.4.9-cp312-cp312-win_amd64.whl", hash = "sha256:f68208a520c3d86ea51acf688a3e3002615a7f0238002cccc17affecc86a8a54", size = 73895 },- { url = "https://files.pythonhosted.org/packages/e2/92/5f3068cf15ee5cb624a0c7596e67e2a0bb2adee33f71c379054a491d07da/kiwisolver-1.4.9-cp312-cp312-win_arm64.whl", hash = "sha256:2c1a4f57df73965f3f14df20b80ee29e6a7930a57d2d9e8491a25f676e197c60", size = 64992 },- { url = "https://files.pythonhosted.org/packages/31/c1/c2686cda909742ab66c7388e9a1a8521a59eb89f8bcfbee28fc980d07e24/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5d0432ccf1c7ab14f9949eec60c5d1f924f17c037e9f8b33352fa05799359b8", size = 123681 },- { url = "https://files.pythonhosted.org/packages/ca/f0/f44f50c9f5b1a1860261092e3bc91ecdc9acda848a8b8c6abfda4a24dd5c/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efb3a45b35622bb6c16dbfab491a8f5a391fe0e9d45ef32f4df85658232ca0e2", size = 66464 },- { url = "https://files.pythonhosted.org/packages/2d/7a/9d90a151f558e29c3936b8a47ac770235f436f2120aca41a6d5f3d62ae8d/kiwisolver-1.4.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1a12cf6398e8a0a001a059747a1cbf24705e18fe413bc22de7b3d15c67cffe3f", size = 64961 },- { url = "https://files.pythonhosted.org/packages/e9/e9/f218a2cb3a9ffbe324ca29a9e399fa2d2866d7f348ec3a88df87fc248fc5/kiwisolver-1.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b67e6efbf68e077dd71d1a6b37e43e1a99d0bff1a3d51867d45ee8908b931098", size = 1474607 },- { url = "https://files.pythonhosted.org/packages/d9/28/aac26d4c882f14de59041636292bc838db8961373825df23b8eeb807e198/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5656aa670507437af0207645273ccdfee4f14bacd7f7c67a4306d0dcaeaf6eed", size = 1276546 },- { url = "https://files.pythonhosted.org/packages/8b/ad/8bfc1c93d4cc565e5069162f610ba2f48ff39b7de4b5b8d93f69f30c4bed/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bfc08add558155345129c7803b3671cf195e6a56e7a12f3dde7c57d9b417f525", size = 1294482 },- { url = "https://files.pythonhosted.org/packages/da/f1/6aca55ff798901d8ce403206d00e033191f63d82dd708a186e0ed2067e9c/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:40092754720b174e6ccf9e845d0d8c7d8e12c3d71e7fc35f55f3813e96376f78", size = 1343720 },- { url = "https://files.pythonhosted.org/packages/d1/91/eed031876c595c81d90d0f6fc681ece250e14bf6998c3d7c419466b523b7/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:497d05f29a1300d14e02e6441cf0f5ee81c1ff5a304b0d9fb77423974684e08b", size = 2224907 },- { url = "https://files.pythonhosted.org/packages/e9/ec/4d1925f2e49617b9cca9c34bfa11adefad49d00db038e692a559454dfb2e/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bdd1a81a1860476eb41ac4bc1e07b3f07259e6d55bbf739b79c8aaedcf512799", size = 2321334 },- { url = "https://files.pythonhosted.org/packages/43/cb/450cd4499356f68802750c6ddc18647b8ea01ffa28f50d20598e0befe6e9/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:e6b93f13371d341afee3be9f7c5964e3fe61d5fa30f6a30eb49856935dfe4fc3", size = 2488313 },- { url = "https://files.pythonhosted.org/packages/71/67/fc76242bd99f885651128a5d4fa6083e5524694b7c88b489b1b55fdc491d/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d75aa530ccfaa593da12834b86a0724f58bff12706659baa9227c2ccaa06264c", size = 2291970 },- { url = "https://files.pythonhosted.org/packages/75/bd/f1a5d894000941739f2ae1b65a32892349423ad49c2e6d0771d0bad3fae4/kiwisolver-1.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:dd0a578400839256df88c16abddf9ba14813ec5f21362e1fe65022e00c883d4d", size = 73894 },- { url = "https://files.pythonhosted.org/packages/95/38/dce480814d25b99a391abbddadc78f7c117c6da34be68ca8b02d5848b424/kiwisolver-1.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:d4188e73af84ca82468f09cadc5ac4db578109e52acb4518d8154698d3a87ca2", size = 64995 },- { url = "https://files.pythonhosted.org/packages/e2/37/7d218ce5d92dadc5ebdd9070d903e0c7cf7edfe03f179433ac4d13ce659c/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5a0f2724dfd4e3b3ac5a82436a8e6fd16baa7d507117e4279b660fe8ca38a3a1", size = 126510 },- { url = "https://files.pythonhosted.org/packages/23/b0/e85a2b48233daef4b648fb657ebbb6f8367696a2d9548a00b4ee0eb67803/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:1b11d6a633e4ed84fc0ddafd4ebfd8ea49b3f25082c04ad12b8315c11d504dc1", size = 67903 },- { url = "https://files.pythonhosted.org/packages/44/98/f2425bc0113ad7de24da6bb4dae1343476e95e1d738be7c04d31a5d037fd/kiwisolver-1.4.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61874cdb0a36016354853593cffc38e56fc9ca5aa97d2c05d3dcf6922cd55a11", size = 66402 },- { url = "https://files.pythonhosted.org/packages/98/d8/594657886df9f34c4177cc353cc28ca7e6e5eb562d37ccc233bff43bbe2a/kiwisolver-1.4.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:60c439763a969a6af93b4881db0eed8fadf93ee98e18cbc35bc8da868d0c4f0c", size = 1582135 },- { url = "https://files.pythonhosted.org/packages/5c/c6/38a115b7170f8b306fc929e166340c24958347308ea3012c2b44e7e295db/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92a2f997387a1b79a75e7803aa7ded2cfbe2823852ccf1ba3bcf613b62ae3197", size = 1389409 },- { url = "https://files.pythonhosted.org/packages/bf/3b/e04883dace81f24a568bcee6eb3001da4ba05114afa622ec9b6fafdc1f5e/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31d512c812daea6d8b3be3b2bfcbeb091dbb09177706569bcfc6240dcf8b41c", size = 1401763 },- { url = "https://files.pythonhosted.org/packages/9f/80/20ace48e33408947af49d7d15c341eaee69e4e0304aab4b7660e234d6288/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:52a15b0f35dad39862d376df10c5230155243a2c1a436e39eb55623ccbd68185", size = 1453643 },- { url = "https://files.pythonhosted.org/packages/64/31/6ce4380a4cd1f515bdda976a1e90e547ccd47b67a1546d63884463c92ca9/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a30fd6fdef1430fd9e1ba7b3398b5ee4e2887783917a687d86ba69985fb08748", size = 2330818 },- { url = "https://files.pythonhosted.org/packages/fa/e9/3f3fcba3bcc7432c795b82646306e822f3fd74df0ee81f0fa067a1f95668/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cc9617b46837c6468197b5945e196ee9ca43057bb7d9d1ae688101e4e1dddf64", size = 2419963 },- { url = "https://files.pythonhosted.org/packages/99/43/7320c50e4133575c66e9f7dadead35ab22d7c012a3b09bb35647792b2a6d/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:0ab74e19f6a2b027ea4f845a78827969af45ce790e6cb3e1ebab71bdf9f215ff", size = 2594639 },- { url = "https://files.pythonhosted.org/packages/65/d6/17ae4a270d4a987ef8a385b906d2bdfc9fce502d6dc0d3aea865b47f548c/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dba5ee5d3981160c28d5490f0d1b7ed730c22470ff7f6cc26cfcfaacb9896a07", size = 2391741 },- { url = "https://files.pythonhosted.org/packages/2a/8f/8f6f491d595a9e5912971f3f863d81baddccc8a4d0c3749d6a0dd9ffc9df/kiwisolver-1.4.9-cp313-cp313t-win_arm64.whl", hash = "sha256:0749fd8f4218ad2e851e11cc4dc05c7cbc0cbc4267bdfdb31782e65aace4ee9c", size = 68646 },- { url = "https://files.pythonhosted.org/packages/6b/32/6cc0fbc9c54d06c2969faa9c1d29f5751a2e51809dd55c69055e62d9b426/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:9928fe1eb816d11ae170885a74d074f57af3a0d65777ca47e9aeb854a1fba386", size = 123806 },- { url = "https://files.pythonhosted.org/packages/b2/dd/2bfb1d4a4823d92e8cbb420fe024b8d2167f72079b3bb941207c42570bdf/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d0005b053977e7b43388ddec89fa567f43d4f6d5c2c0affe57de5ebf290dc552", size = 66605 },- { url = "https://files.pythonhosted.org/packages/f7/69/00aafdb4e4509c2ca6064646cba9cd4b37933898f426756adb2cb92ebbed/kiwisolver-1.4.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2635d352d67458b66fd0667c14cb1d4145e9560d503219034a18a87e971ce4f3", size = 64925 },- { url = "https://files.pythonhosted.org/packages/43/dc/51acc6791aa14e5cb6d8a2e28cefb0dc2886d8862795449d021334c0df20/kiwisolver-1.4.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:767c23ad1c58c9e827b649a9ab7809fd5fd9db266a9cf02b0e926ddc2c680d58", size = 1472414 },- { url = "https://files.pythonhosted.org/packages/3d/bb/93fa64a81db304ac8a246f834d5094fae4b13baf53c839d6bb6e81177129/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72d0eb9fba308b8311685c2268cf7d0a0639a6cd027d8128659f72bdd8a024b4", size = 1281272 },- { url = "https://files.pythonhosted.org/packages/70/e6/6df102916960fb8d05069d4bd92d6d9a8202d5a3e2444494e7cd50f65b7a/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f68e4f3eeca8fb22cc3d731f9715a13b652795ef657a13df1ad0c7dc0e9731df", size = 1298578 },- { url = "https://files.pythonhosted.org/packages/7c/47/e142aaa612f5343736b087864dbaebc53ea8831453fb47e7521fa8658f30/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d84cd4061ae292d8ac367b2c3fa3aad11cb8625a95d135fe93f286f914f3f5a6", size = 1345607 },- { url = "https://files.pythonhosted.org/packages/54/89/d641a746194a0f4d1a3670fb900d0dbaa786fb98341056814bc3f058fa52/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a60ea74330b91bd22a29638940d115df9dc00af5035a9a2a6ad9399ffb4ceca5", size = 2230150 },- { url = "https://files.pythonhosted.org/packages/aa/6b/5ee1207198febdf16ac11f78c5ae40861b809cbe0e6d2a8d5b0b3044b199/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ce6a3a4e106cf35c2d9c4fa17c05ce0b180db622736845d4315519397a77beaf", size = 2325979 },- { url = "https://files.pythonhosted.org/packages/fc/ff/b269eefd90f4ae14dcc74973d5a0f6d28d3b9bb1afd8c0340513afe6b39a/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:77937e5e2a38a7b48eef0585114fe7930346993a88060d0bf886086d2aa49ef5", size = 2491456 },- { url = "https://files.pythonhosted.org/packages/fc/d4/10303190bd4d30de547534601e259a4fbf014eed94aae3e5521129215086/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:24c175051354f4a28c5d6a31c93906dc653e2bf234e8a4bbfb964892078898ce", size = 2294621 },- { url = "https://files.pythonhosted.org/packages/28/e0/a9a90416fce5c0be25742729c2ea52105d62eda6c4be4d803c2a7be1fa50/kiwisolver-1.4.9-cp314-cp314-win_amd64.whl", hash = "sha256:0763515d4df10edf6d06a3c19734e2566368980d21ebec439f33f9eb936c07b7", size = 75417 },- { url = "https://files.pythonhosted.org/packages/1f/10/6949958215b7a9a264299a7db195564e87900f709db9245e4ebdd3c70779/kiwisolver-1.4.9-cp314-cp314-win_arm64.whl", hash = "sha256:0e4e2bf29574a6a7b7f6cb5fa69293b9f96c928949ac4a53ba3f525dffb87f9c", size = 66582 },- { url = "https://files.pythonhosted.org/packages/ec/79/60e53067903d3bc5469b369fe0dfc6b3482e2133e85dae9daa9527535991/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d976bbb382b202f71c67f77b0ac11244021cfa3f7dfd9e562eefcea2df711548", size = 126514 },- { url = "https://files.pythonhosted.org/packages/25/d1/4843d3e8d46b072c12a38c97c57fab4608d36e13fe47d47ee96b4d61ba6f/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2489e4e5d7ef9a1c300a5e0196e43d9c739f066ef23270607d45aba368b91f2d", size = 67905 },- { url = "https://files.pythonhosted.org/packages/8c/ae/29ffcbd239aea8b93108de1278271ae764dfc0d803a5693914975f200596/kiwisolver-1.4.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e2ea9f7ab7fbf18fffb1b5434ce7c69a07582f7acc7717720f1d69f3e806f90c", size = 66399 },- { url = "https://files.pythonhosted.org/packages/a1/ae/d7ba902aa604152c2ceba5d352d7b62106bedbccc8e95c3934d94472bfa3/kiwisolver-1.4.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b34e51affded8faee0dfdb705416153819d8ea9250bbbf7ea1b249bdeb5f1122", size = 1582197 },- { url = "https://files.pythonhosted.org/packages/f2/41/27c70d427eddb8bc7e4f16420a20fefc6f480312122a59a959fdfe0445ad/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8aacd3d4b33b772542b2e01beb50187536967b514b00003bdda7589722d2a64", size = 1390125 },- { url = "https://files.pythonhosted.org/packages/41/42/b3799a12bafc76d962ad69083f8b43b12bf4fe78b097b12e105d75c9b8f1/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7cf974dd4e35fa315563ac99d6287a1024e4dc2077b8a7d7cd3d2fb65d283134", size = 1402612 },- { url = "https://files.pythonhosted.org/packages/d2/b5/a210ea073ea1cfaca1bb5c55a62307d8252f531beb364e18aa1e0888b5a0/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:85bd218b5ecfbee8c8a82e121802dcb519a86044c9c3b2e4aef02fa05c6da370", size = 1453990 },- { url = "https://files.pythonhosted.org/packages/5f/ce/a829eb8c033e977d7ea03ed32fb3c1781b4fa0433fbadfff29e39c676f32/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0856e241c2d3df4efef7c04a1e46b1936b6120c9bcf36dd216e3acd84bc4fb21", size = 2331601 },- { url = "https://files.pythonhosted.org/packages/e0/4b/b5e97eb142eb9cd0072dacfcdcd31b1c66dc7352b0f7c7255d339c0edf00/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9af39d6551f97d31a4deebeac6f45b156f9755ddc59c07b402c148f5dbb6482a", size = 2422041 },- { url = "https://files.pythonhosted.org/packages/40/be/8eb4cd53e1b85ba4edc3a9321666f12b83113a178845593307a3e7891f44/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:bb4ae2b57fc1d8cbd1cf7b1d9913803681ffa903e7488012be5b76dedf49297f", size = 2594897 },- { url = "https://files.pythonhosted.org/packages/99/dd/841e9a66c4715477ea0abc78da039832fbb09dac5c35c58dc4c41a407b8a/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:aedff62918805fb62d43a4aa2ecd4482c380dc76cd31bd7c8878588a61bd0369", size = 2391835 },- { url = "https://files.pythonhosted.org/packages/0c/28/4b2e5c47a0da96896fdfdb006340ade064afa1e63675d01ea5ac222b6d52/kiwisolver-1.4.9-cp314-cp314t-win_amd64.whl", hash = "sha256:1fa333e8b2ce4d9660f2cda9c0e1b6bafcfb2457a9d259faa82289e73ec24891", size = 79988 },- { url = "https://files.pythonhosted.org/packages/80/be/3578e8afd18c88cdf9cb4cffde75a96d2be38c5a903f1ed0ceec061bd09e/kiwisolver-1.4.9-cp314-cp314t-win_arm64.whl", hash = "sha256:4a48a2ce79d65d363597ef7b567ce3d14d68783d2b2263d98db3d9477805ba32", size = 70260 },- { url = "https://files.pythonhosted.org/packages/a3/0f/36d89194b5a32c054ce93e586d4049b6c2c22887b0eb229c61c68afd3078/kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:720e05574713db64c356e86732c0f3c5252818d05f9df320f0ad8380641acea5", size = 60104 },- { url = "https://files.pythonhosted.org/packages/52/ba/4ed75f59e4658fd21fe7dde1fee0ac397c678ec3befba3fe6482d987af87/kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:17680d737d5335b552994a2008fab4c851bcd7de33094a82067ef3a576ff02fa", size = 58592 },- { url = "https://files.pythonhosted.org/packages/33/01/a8ea7c5ea32a9b45ceeaee051a04c8ed4320f5add3c51bfa20879b765b70/kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:85b5352f94e490c028926ea567fc569c52ec79ce131dadb968d3853e809518c2", size = 80281 },- { url = "https://files.pythonhosted.org/packages/da/e3/dbd2ecdce306f1d07a1aaf324817ee993aab7aee9db47ceac757deabafbe/kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:464415881e4801295659462c49461a24fb107c140de781d55518c4b80cb6790f", size = 78009 },- { url = "https://files.pythonhosted.org/packages/da/e9/0d4add7873a73e462aeb45c036a2dead2562b825aa46ba326727b3f31016/kiwisolver-1.4.9-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:fb940820c63a9590d31d88b815e7a3aa5915cad3ce735ab45f0c730b39547de1", size = 73929 },+sdist = { url = "https://files.pythonhosted.org/packages/5c/3c/85844f1b0feb11ee581ac23fe5fce65cd049a200c1446708cc1b7f922875/kiwisolver-1.4.9.tar.gz", hash = "sha256:c3b22c26c6fd6811b0ae8363b95ca8ce4ea3c202d3d0975b2914310ceb1bcc4d", size = 97564, upload-time = "2025-08-10T21:27:49.279Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/6f/ab/c80b0d5a9d8a1a65f4f815f2afff9798b12c3b9f31f1d304dd233dd920e2/kiwisolver-1.4.9-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb14a5da6dc7642b0f3a18f13654847cd8b7a2550e2645a5bda677862b03ba16", size = 124167, upload-time = "2025-08-10T21:25:53.403Z" },+ { url = "https://files.pythonhosted.org/packages/a0/c0/27fe1a68a39cf62472a300e2879ffc13c0538546c359b86f149cc19f6ac3/kiwisolver-1.4.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:39a219e1c81ae3b103643d2aedb90f1ef22650deb266ff12a19e7773f3e5f089", size = 66579, upload-time = "2025-08-10T21:25:54.79Z" },+ { url = "https://files.pythonhosted.org/packages/31/a2/a12a503ac1fd4943c50f9822678e8015a790a13b5490354c68afb8489814/kiwisolver-1.4.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2405a7d98604b87f3fc28b1716783534b1b4b8510d8142adca34ee0bc3c87543", size = 65309, upload-time = "2025-08-10T21:25:55.76Z" },+ { url = "https://files.pythonhosted.org/packages/66/e1/e533435c0be77c3f64040d68d7a657771194a63c279f55573188161e81ca/kiwisolver-1.4.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:dc1ae486f9abcef254b5618dfb4113dd49f94c68e3e027d03cf0143f3f772b61", size = 1435596, upload-time = "2025-08-10T21:25:56.861Z" },+ { url = "https://files.pythonhosted.org/packages/67/1e/51b73c7347f9aabdc7215aa79e8b15299097dc2f8e67dee2b095faca9cb0/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a1f570ce4d62d718dce3f179ee78dac3b545ac16c0c04bb363b7607a949c0d1", size = 1246548, upload-time = "2025-08-10T21:25:58.246Z" },+ { url = "https://files.pythonhosted.org/packages/21/aa/72a1c5d1e430294f2d32adb9542719cfb441b5da368d09d268c7757af46c/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb27e7b78d716c591e88e0a09a2139c6577865d7f2e152488c2cc6257f460872", size = 1263618, upload-time = "2025-08-10T21:25:59.857Z" },+ { url = "https://files.pythonhosted.org/packages/a3/af/db1509a9e79dbf4c260ce0cfa3903ea8945f6240e9e59d1e4deb731b1a40/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:15163165efc2f627eb9687ea5f3a28137217d217ac4024893d753f46bce9de26", size = 1317437, upload-time = "2025-08-10T21:26:01.105Z" },+ { url = "https://files.pythonhosted.org/packages/e0/f2/3ea5ee5d52abacdd12013a94130436e19969fa183faa1e7c7fbc89e9a42f/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bdee92c56a71d2b24c33a7d4c2856bd6419d017e08caa7802d2963870e315028", size = 2195742, upload-time = "2025-08-10T21:26:02.675Z" },+ { url = "https://files.pythonhosted.org/packages/6f/9b/1efdd3013c2d9a2566aa6a337e9923a00590c516add9a1e89a768a3eb2fc/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:412f287c55a6f54b0650bd9b6dce5aceddb95864a1a90c87af16979d37c89771", size = 2290810, upload-time = "2025-08-10T21:26:04.009Z" },+ { url = "https://files.pythonhosted.org/packages/fb/e5/cfdc36109ae4e67361f9bc5b41323648cb24a01b9ade18784657e022e65f/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2c93f00dcba2eea70af2be5f11a830a742fe6b579a1d4e00f47760ef13be247a", size = 2461579, upload-time = "2025-08-10T21:26:05.317Z" },+ { url = "https://files.pythonhosted.org/packages/62/86/b589e5e86c7610842213994cdea5add00960076bef4ae290c5fa68589cac/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f117e1a089d9411663a3207ba874f31be9ac8eaa5b533787024dc07aeb74f464", size = 2268071, upload-time = "2025-08-10T21:26:06.686Z" },+ { url = "https://files.pythonhosted.org/packages/3b/c6/f8df8509fd1eee6c622febe54384a96cfaf4d43bf2ccec7a0cc17e4715c9/kiwisolver-1.4.9-cp311-cp311-win_amd64.whl", hash = "sha256:be6a04e6c79819c9a8c2373317d19a96048e5a3f90bec587787e86a1153883c2", size = 73840, upload-time = "2025-08-10T21:26:07.94Z" },+ { url = "https://files.pythonhosted.org/packages/e2/2d/16e0581daafd147bc11ac53f032a2b45eabac897f42a338d0a13c1e5c436/kiwisolver-1.4.9-cp311-cp311-win_arm64.whl", hash = "sha256:0ae37737256ba2de764ddc12aed4956460277f00c4996d51a197e72f62f5eec7", size = 65159, upload-time = "2025-08-10T21:26:09.048Z" },+ { url = "https://files.pythonhosted.org/packages/86/c9/13573a747838aeb1c76e3267620daa054f4152444d1f3d1a2324b78255b5/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ac5a486ac389dddcc5bef4f365b6ae3ffff2c433324fb38dd35e3fab7c957999", size = 123686, upload-time = "2025-08-10T21:26:10.034Z" },+ { url = "https://files.pythonhosted.org/packages/51/ea/2ecf727927f103ffd1739271ca19c424d0e65ea473fbaeea1c014aea93f6/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f2ba92255faa7309d06fe44c3a4a97efe1c8d640c2a79a5ef728b685762a6fd2", size = 66460, upload-time = "2025-08-10T21:26:11.083Z" },+ { url = "https://files.pythonhosted.org/packages/5b/5a/51f5464373ce2aeb5194508298a508b6f21d3867f499556263c64c621914/kiwisolver-1.4.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a2899935e724dd1074cb568ce7ac0dce28b2cd6ab539c8e001a8578eb106d14", size = 64952, upload-time = "2025-08-10T21:26:12.058Z" },+ { url = "https://files.pythonhosted.org/packages/70/90/6d240beb0f24b74371762873e9b7f499f1e02166a2d9c5801f4dbf8fa12e/kiwisolver-1.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f6008a4919fdbc0b0097089f67a1eb55d950ed7e90ce2cc3e640abadd2757a04", size = 1474756, upload-time = "2025-08-10T21:26:13.096Z" },+ { url = "https://files.pythonhosted.org/packages/12/42/f36816eaf465220f683fb711efdd1bbf7a7005a2473d0e4ed421389bd26c/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:67bb8b474b4181770f926f7b7d2f8c0248cbcb78b660fdd41a47054b28d2a752", size = 1276404, upload-time = "2025-08-10T21:26:14.457Z" },+ { url = "https://files.pythonhosted.org/packages/2e/64/bc2de94800adc830c476dce44e9b40fd0809cddeef1fde9fcf0f73da301f/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2327a4a30d3ee07d2fbe2e7933e8a37c591663b96ce42a00bc67461a87d7df77", size = 1294410, upload-time = "2025-08-10T21:26:15.73Z" },+ { url = "https://files.pythonhosted.org/packages/5f/42/2dc82330a70aa8e55b6d395b11018045e58d0bb00834502bf11509f79091/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a08b491ec91b1d5053ac177afe5290adacf1f0f6307d771ccac5de30592d198", size = 1343631, upload-time = "2025-08-10T21:26:17.045Z" },+ { url = "https://files.pythonhosted.org/packages/22/fd/f4c67a6ed1aab149ec5a8a401c323cee7a1cbe364381bb6c9c0d564e0e20/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8fc5c867c22b828001b6a38d2eaeb88160bf5783c6cb4a5e440efc981ce286d", size = 2224963, upload-time = "2025-08-10T21:26:18.737Z" },+ { url = "https://files.pythonhosted.org/packages/45/aa/76720bd4cb3713314677d9ec94dcc21ced3f1baf4830adde5bb9b2430a5f/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3b3115b2581ea35bb6d1f24a4c90af37e5d9b49dcff267eeed14c3893c5b86ab", size = 2321295, upload-time = "2025-08-10T21:26:20.11Z" },+ { url = "https://files.pythonhosted.org/packages/80/19/d3ec0d9ab711242f56ae0dc2fc5d70e298bb4a1f9dfab44c027668c673a1/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858e4c22fb075920b96a291928cb7dea5644e94c0ee4fcd5af7e865655e4ccf2", size = 2487987, upload-time = "2025-08-10T21:26:21.49Z" },+ { url = "https://files.pythonhosted.org/packages/39/e9/61e4813b2c97e86b6fdbd4dd824bf72d28bcd8d4849b8084a357bc0dd64d/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ed0fecd28cc62c54b262e3736f8bb2512d8dcfdc2bcf08be5f47f96bf405b145", size = 2291817, upload-time = "2025-08-10T21:26:22.812Z" },+ { url = "https://files.pythonhosted.org/packages/a0/41/85d82b0291db7504da3c2defe35c9a8a5c9803a730f297bd823d11d5fb77/kiwisolver-1.4.9-cp312-cp312-win_amd64.whl", hash = "sha256:f68208a520c3d86ea51acf688a3e3002615a7f0238002cccc17affecc86a8a54", size = 73895, upload-time = "2025-08-10T21:26:24.37Z" },+ { url = "https://files.pythonhosted.org/packages/e2/92/5f3068cf15ee5cb624a0c7596e67e2a0bb2adee33f71c379054a491d07da/kiwisolver-1.4.9-cp312-cp312-win_arm64.whl", hash = "sha256:2c1a4f57df73965f3f14df20b80ee29e6a7930a57d2d9e8491a25f676e197c60", size = 64992, upload-time = "2025-08-10T21:26:25.732Z" },+ { url = "https://files.pythonhosted.org/packages/31/c1/c2686cda909742ab66c7388e9a1a8521a59eb89f8bcfbee28fc980d07e24/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5d0432ccf1c7ab14f9949eec60c5d1f924f17c037e9f8b33352fa05799359b8", size = 123681, upload-time = "2025-08-10T21:26:26.725Z" },+ { url = "https://files.pythonhosted.org/packages/ca/f0/f44f50c9f5b1a1860261092e3bc91ecdc9acda848a8b8c6abfda4a24dd5c/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efb3a45b35622bb6c16dbfab491a8f5a391fe0e9d45ef32f4df85658232ca0e2", size = 66464, upload-time = "2025-08-10T21:26:27.733Z" },+ { url = "https://files.pythonhosted.org/packages/2d/7a/9d90a151f558e29c3936b8a47ac770235f436f2120aca41a6d5f3d62ae8d/kiwisolver-1.4.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1a12cf6398e8a0a001a059747a1cbf24705e18fe413bc22de7b3d15c67cffe3f", size = 64961, upload-time = "2025-08-10T21:26:28.729Z" },+ { url = "https://files.pythonhosted.org/packages/e9/e9/f218a2cb3a9ffbe324ca29a9e399fa2d2866d7f348ec3a88df87fc248fc5/kiwisolver-1.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b67e6efbf68e077dd71d1a6b37e43e1a99d0bff1a3d51867d45ee8908b931098", size = 1474607, upload-time = "2025-08-10T21:26:29.798Z" },+ { url = "https://files.pythonhosted.org/packages/d9/28/aac26d4c882f14de59041636292bc838db8961373825df23b8eeb807e198/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5656aa670507437af0207645273ccdfee4f14bacd7f7c67a4306d0dcaeaf6eed", size = 1276546, upload-time = "2025-08-10T21:26:31.401Z" },+ { url = "https://files.pythonhosted.org/packages/8b/ad/8bfc1c93d4cc565e5069162f610ba2f48ff39b7de4b5b8d93f69f30c4bed/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bfc08add558155345129c7803b3671cf195e6a56e7a12f3dde7c57d9b417f525", size = 1294482, upload-time = "2025-08-10T21:26:32.721Z" },+ { url = "https://files.pythonhosted.org/packages/da/f1/6aca55ff798901d8ce403206d00e033191f63d82dd708a186e0ed2067e9c/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:40092754720b174e6ccf9e845d0d8c7d8e12c3d71e7fc35f55f3813e96376f78", size = 1343720, upload-time = "2025-08-10T21:26:34.032Z" },+ { url = "https://files.pythonhosted.org/packages/d1/91/eed031876c595c81d90d0f6fc681ece250e14bf6998c3d7c419466b523b7/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:497d05f29a1300d14e02e6441cf0f5ee81c1ff5a304b0d9fb77423974684e08b", size = 2224907, upload-time = "2025-08-10T21:26:35.824Z" },+ { url = "https://files.pythonhosted.org/packages/e9/ec/4d1925f2e49617b9cca9c34bfa11adefad49d00db038e692a559454dfb2e/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bdd1a81a1860476eb41ac4bc1e07b3f07259e6d55bbf739b79c8aaedcf512799", size = 2321334, upload-time = "2025-08-10T21:26:37.534Z" },+ { url = "https://files.pythonhosted.org/packages/43/cb/450cd4499356f68802750c6ddc18647b8ea01ffa28f50d20598e0befe6e9/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:e6b93f13371d341afee3be9f7c5964e3fe61d5fa30f6a30eb49856935dfe4fc3", size = 2488313, upload-time = "2025-08-10T21:26:39.191Z" },+ { url = "https://files.pythonhosted.org/packages/71/67/fc76242bd99f885651128a5d4fa6083e5524694b7c88b489b1b55fdc491d/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d75aa530ccfaa593da12834b86a0724f58bff12706659baa9227c2ccaa06264c", size = 2291970, upload-time = "2025-08-10T21:26:40.828Z" },+ { url = "https://files.pythonhosted.org/packages/75/bd/f1a5d894000941739f2ae1b65a32892349423ad49c2e6d0771d0bad3fae4/kiwisolver-1.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:dd0a578400839256df88c16abddf9ba14813ec5f21362e1fe65022e00c883d4d", size = 73894, upload-time = "2025-08-10T21:26:42.33Z" },+ { url = "https://files.pythonhosted.org/packages/95/38/dce480814d25b99a391abbddadc78f7c117c6da34be68ca8b02d5848b424/kiwisolver-1.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:d4188e73af84ca82468f09cadc5ac4db578109e52acb4518d8154698d3a87ca2", size = 64995, upload-time = "2025-08-10T21:26:43.889Z" },+ { url = "https://files.pythonhosted.org/packages/e2/37/7d218ce5d92dadc5ebdd9070d903e0c7cf7edfe03f179433ac4d13ce659c/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5a0f2724dfd4e3b3ac5a82436a8e6fd16baa7d507117e4279b660fe8ca38a3a1", size = 126510, upload-time = "2025-08-10T21:26:44.915Z" },+ { url = "https://files.pythonhosted.org/packages/23/b0/e85a2b48233daef4b648fb657ebbb6f8367696a2d9548a00b4ee0eb67803/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:1b11d6a633e4ed84fc0ddafd4ebfd8ea49b3f25082c04ad12b8315c11d504dc1", size = 67903, upload-time = "2025-08-10T21:26:45.934Z" },+ { url = "https://files.pythonhosted.org/packages/44/98/f2425bc0113ad7de24da6bb4dae1343476e95e1d738be7c04d31a5d037fd/kiwisolver-1.4.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61874cdb0a36016354853593cffc38e56fc9ca5aa97d2c05d3dcf6922cd55a11", size = 66402, upload-time = "2025-08-10T21:26:47.101Z" },+ { url = "https://files.pythonhosted.org/packages/98/d8/594657886df9f34c4177cc353cc28ca7e6e5eb562d37ccc233bff43bbe2a/kiwisolver-1.4.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:60c439763a969a6af93b4881db0eed8fadf93ee98e18cbc35bc8da868d0c4f0c", size = 1582135, upload-time = "2025-08-10T21:26:48.665Z" },+ { url = "https://files.pythonhosted.org/packages/5c/c6/38a115b7170f8b306fc929e166340c24958347308ea3012c2b44e7e295db/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92a2f997387a1b79a75e7803aa7ded2cfbe2823852ccf1ba3bcf613b62ae3197", size = 1389409, upload-time = "2025-08-10T21:26:50.335Z" },+ { url = "https://files.pythonhosted.org/packages/bf/3b/e04883dace81f24a568bcee6eb3001da4ba05114afa622ec9b6fafdc1f5e/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31d512c812daea6d8b3be3b2bfcbeb091dbb09177706569bcfc6240dcf8b41c", size = 1401763, upload-time = "2025-08-10T21:26:51.867Z" },+ { url = "https://files.pythonhosted.org/packages/9f/80/20ace48e33408947af49d7d15c341eaee69e4e0304aab4b7660e234d6288/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:52a15b0f35dad39862d376df10c5230155243a2c1a436e39eb55623ccbd68185", size = 1453643, upload-time = "2025-08-10T21:26:53.592Z" },+ { url = "https://files.pythonhosted.org/packages/64/31/6ce4380a4cd1f515bdda976a1e90e547ccd47b67a1546d63884463c92ca9/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a30fd6fdef1430fd9e1ba7b3398b5ee4e2887783917a687d86ba69985fb08748", size = 2330818, upload-time = "2025-08-10T21:26:55.051Z" },+ { url = "https://files.pythonhosted.org/packages/fa/e9/3f3fcba3bcc7432c795b82646306e822f3fd74df0ee81f0fa067a1f95668/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cc9617b46837c6468197b5945e196ee9ca43057bb7d9d1ae688101e4e1dddf64", size = 2419963, upload-time = "2025-08-10T21:26:56.421Z" },+ { url = "https://files.pythonhosted.org/packages/99/43/7320c50e4133575c66e9f7dadead35ab22d7c012a3b09bb35647792b2a6d/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:0ab74e19f6a2b027ea4f845a78827969af45ce790e6cb3e1ebab71bdf9f215ff", size = 2594639, upload-time = "2025-08-10T21:26:57.882Z" },+ { url = "https://files.pythonhosted.org/packages/65/d6/17ae4a270d4a987ef8a385b906d2bdfc9fce502d6dc0d3aea865b47f548c/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dba5ee5d3981160c28d5490f0d1b7ed730c22470ff7f6cc26cfcfaacb9896a07", size = 2391741, upload-time = "2025-08-10T21:26:59.237Z" },+ { url = "https://files.pythonhosted.org/packages/2a/8f/8f6f491d595a9e5912971f3f863d81baddccc8a4d0c3749d6a0dd9ffc9df/kiwisolver-1.4.9-cp313-cp313t-win_arm64.whl", hash = "sha256:0749fd8f4218ad2e851e11cc4dc05c7cbc0cbc4267bdfdb31782e65aace4ee9c", size = 68646, upload-time = "2025-08-10T21:27:00.52Z" },+ { url = "https://files.pythonhosted.org/packages/6b/32/6cc0fbc9c54d06c2969faa9c1d29f5751a2e51809dd55c69055e62d9b426/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:9928fe1eb816d11ae170885a74d074f57af3a0d65777ca47e9aeb854a1fba386", size = 123806, upload-time = "2025-08-10T21:27:01.537Z" },+ { url = "https://files.pythonhosted.org/packages/b2/dd/2bfb1d4a4823d92e8cbb420fe024b8d2167f72079b3bb941207c42570bdf/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d0005b053977e7b43388ddec89fa567f43d4f6d5c2c0affe57de5ebf290dc552", size = 66605, upload-time = "2025-08-10T21:27:03.335Z" },+ { url = "https://files.pythonhosted.org/packages/f7/69/00aafdb4e4509c2ca6064646cba9cd4b37933898f426756adb2cb92ebbed/kiwisolver-1.4.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2635d352d67458b66fd0667c14cb1d4145e9560d503219034a18a87e971ce4f3", size = 64925, upload-time = "2025-08-10T21:27:04.339Z" },+ { url = "https://files.pythonhosted.org/packages/43/dc/51acc6791aa14e5cb6d8a2e28cefb0dc2886d8862795449d021334c0df20/kiwisolver-1.4.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:767c23ad1c58c9e827b649a9ab7809fd5fd9db266a9cf02b0e926ddc2c680d58", size = 1472414, upload-time = "2025-08-10T21:27:05.437Z" },+ { url = "https://files.pythonhosted.org/packages/3d/bb/93fa64a81db304ac8a246f834d5094fae4b13baf53c839d6bb6e81177129/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72d0eb9fba308b8311685c2268cf7d0a0639a6cd027d8128659f72bdd8a024b4", size = 1281272, upload-time = "2025-08-10T21:27:07.063Z" },+ { url = "https://files.pythonhosted.org/packages/70/e6/6df102916960fb8d05069d4bd92d6d9a8202d5a3e2444494e7cd50f65b7a/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f68e4f3eeca8fb22cc3d731f9715a13b652795ef657a13df1ad0c7dc0e9731df", size = 1298578, upload-time = "2025-08-10T21:27:08.452Z" },+ { url = "https://files.pythonhosted.org/packages/7c/47/e142aaa612f5343736b087864dbaebc53ea8831453fb47e7521fa8658f30/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d84cd4061ae292d8ac367b2c3fa3aad11cb8625a95d135fe93f286f914f3f5a6", size = 1345607, upload-time = "2025-08-10T21:27:10.125Z" },+ { url = "https://files.pythonhosted.org/packages/54/89/d641a746194a0f4d1a3670fb900d0dbaa786fb98341056814bc3f058fa52/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a60ea74330b91bd22a29638940d115df9dc00af5035a9a2a6ad9399ffb4ceca5", size = 2230150, upload-time = "2025-08-10T21:27:11.484Z" },+ { url = "https://files.pythonhosted.org/packages/aa/6b/5ee1207198febdf16ac11f78c5ae40861b809cbe0e6d2a8d5b0b3044b199/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ce6a3a4e106cf35c2d9c4fa17c05ce0b180db622736845d4315519397a77beaf", size = 2325979, upload-time = "2025-08-10T21:27:12.917Z" },+ { url = "https://files.pythonhosted.org/packages/fc/ff/b269eefd90f4ae14dcc74973d5a0f6d28d3b9bb1afd8c0340513afe6b39a/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:77937e5e2a38a7b48eef0585114fe7930346993a88060d0bf886086d2aa49ef5", size = 2491456, upload-time = "2025-08-10T21:27:14.353Z" },+ { url = "https://files.pythonhosted.org/packages/fc/d4/10303190bd4d30de547534601e259a4fbf014eed94aae3e5521129215086/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:24c175051354f4a28c5d6a31c93906dc653e2bf234e8a4bbfb964892078898ce", size = 2294621, upload-time = "2025-08-10T21:27:15.808Z" },+ { url = "https://files.pythonhosted.org/packages/28/e0/a9a90416fce5c0be25742729c2ea52105d62eda6c4be4d803c2a7be1fa50/kiwisolver-1.4.9-cp314-cp314-win_amd64.whl", hash = "sha256:0763515d4df10edf6d06a3c19734e2566368980d21ebec439f33f9eb936c07b7", size = 75417, upload-time = "2025-08-10T21:27:17.436Z" },+ { url = "https://files.pythonhosted.org/packages/1f/10/6949958215b7a9a264299a7db195564e87900f709db9245e4ebdd3c70779/kiwisolver-1.4.9-cp314-cp314-win_arm64.whl", hash = "sha256:0e4e2bf29574a6a7b7f6cb5fa69293b9f96c928949ac4a53ba3f525dffb87f9c", size = 66582, upload-time = "2025-08-10T21:27:18.436Z" },+ { url = "https://files.pythonhosted.org/packages/ec/79/60e53067903d3bc5469b369fe0dfc6b3482e2133e85dae9daa9527535991/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d976bbb382b202f71c67f77b0ac11244021cfa3f7dfd9e562eefcea2df711548", size = 126514, upload-time = "2025-08-10T21:27:19.465Z" },+ { url = "https://files.pythonhosted.org/packages/25/d1/4843d3e8d46b072c12a38c97c57fab4608d36e13fe47d47ee96b4d61ba6f/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2489e4e5d7ef9a1c300a5e0196e43d9c739f066ef23270607d45aba368b91f2d", size = 67905, upload-time = "2025-08-10T21:27:20.51Z" },+ { url = "https://files.pythonhosted.org/packages/8c/ae/29ffcbd239aea8b93108de1278271ae764dfc0d803a5693914975f200596/kiwisolver-1.4.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e2ea9f7ab7fbf18fffb1b5434ce7c69a07582f7acc7717720f1d69f3e806f90c", size = 66399, upload-time = "2025-08-10T21:27:21.496Z" },+ { url = "https://files.pythonhosted.org/packages/a1/ae/d7ba902aa604152c2ceba5d352d7b62106bedbccc8e95c3934d94472bfa3/kiwisolver-1.4.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b34e51affded8faee0dfdb705416153819d8ea9250bbbf7ea1b249bdeb5f1122", size = 1582197, upload-time = "2025-08-10T21:27:22.604Z" },+ { url = "https://files.pythonhosted.org/packages/f2/41/27c70d427eddb8bc7e4f16420a20fefc6f480312122a59a959fdfe0445ad/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8aacd3d4b33b772542b2e01beb50187536967b514b00003bdda7589722d2a64", size = 1390125, upload-time = "2025-08-10T21:27:24.036Z" },+ { url = "https://files.pythonhosted.org/packages/41/42/b3799a12bafc76d962ad69083f8b43b12bf4fe78b097b12e105d75c9b8f1/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7cf974dd4e35fa315563ac99d6287a1024e4dc2077b8a7d7cd3d2fb65d283134", size = 1402612, upload-time = "2025-08-10T21:27:25.773Z" },+ { url = "https://files.pythonhosted.org/packages/d2/b5/a210ea073ea1cfaca1bb5c55a62307d8252f531beb364e18aa1e0888b5a0/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:85bd218b5ecfbee8c8a82e121802dcb519a86044c9c3b2e4aef02fa05c6da370", size = 1453990, upload-time = "2025-08-10T21:27:27.089Z" },+ { url = "https://files.pythonhosted.org/packages/5f/ce/a829eb8c033e977d7ea03ed32fb3c1781b4fa0433fbadfff29e39c676f32/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0856e241c2d3df4efef7c04a1e46b1936b6120c9bcf36dd216e3acd84bc4fb21", size = 2331601, upload-time = "2025-08-10T21:27:29.343Z" },+ { url = "https://files.pythonhosted.org/packages/e0/4b/b5e97eb142eb9cd0072dacfcdcd31b1c66dc7352b0f7c7255d339c0edf00/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9af39d6551f97d31a4deebeac6f45b156f9755ddc59c07b402c148f5dbb6482a", size = 2422041, upload-time = "2025-08-10T21:27:30.754Z" },+ { url = "https://files.pythonhosted.org/packages/40/be/8eb4cd53e1b85ba4edc3a9321666f12b83113a178845593307a3e7891f44/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:bb4ae2b57fc1d8cbd1cf7b1d9913803681ffa903e7488012be5b76dedf49297f", size = 2594897, upload-time = "2025-08-10T21:27:32.803Z" },+ { url = "https://files.pythonhosted.org/packages/99/dd/841e9a66c4715477ea0abc78da039832fbb09dac5c35c58dc4c41a407b8a/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:aedff62918805fb62d43a4aa2ecd4482c380dc76cd31bd7c8878588a61bd0369", size = 2391835, upload-time = "2025-08-10T21:27:34.23Z" },+ { url = "https://files.pythonhosted.org/packages/0c/28/4b2e5c47a0da96896fdfdb006340ade064afa1e63675d01ea5ac222b6d52/kiwisolver-1.4.9-cp314-cp314t-win_amd64.whl", hash = "sha256:1fa333e8b2ce4d9660f2cda9c0e1b6bafcfb2457a9d259faa82289e73ec24891", size = 79988, upload-time = "2025-08-10T21:27:35.587Z" },+ { url = "https://files.pythonhosted.org/packages/80/be/3578e8afd18c88cdf9cb4cffde75a96d2be38c5a903f1ed0ceec061bd09e/kiwisolver-1.4.9-cp314-cp314t-win_arm64.whl", hash = "sha256:4a48a2ce79d65d363597ef7b567ce3d14d68783d2b2263d98db3d9477805ba32", size = 70260, upload-time = "2025-08-10T21:27:36.606Z" },+ { url = "https://files.pythonhosted.org/packages/a3/0f/36d89194b5a32c054ce93e586d4049b6c2c22887b0eb229c61c68afd3078/kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:720e05574713db64c356e86732c0f3c5252818d05f9df320f0ad8380641acea5", size = 60104, upload-time = "2025-08-10T21:27:43.287Z" },+ { url = "https://files.pythonhosted.org/packages/52/ba/4ed75f59e4658fd21fe7dde1fee0ac397c678ec3befba3fe6482d987af87/kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:17680d737d5335b552994a2008fab4c851bcd7de33094a82067ef3a576ff02fa", size = 58592, upload-time = "2025-08-10T21:27:44.314Z" },+ { url = "https://files.pythonhosted.org/packages/33/01/a8ea7c5ea32a9b45ceeaee051a04c8ed4320f5add3c51bfa20879b765b70/kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:85b5352f94e490c028926ea567fc569c52ec79ce131dadb968d3853e809518c2", size = 80281, upload-time = "2025-08-10T21:27:45.369Z" },+ { url = "https://files.pythonhosted.org/packages/da/e3/dbd2ecdce306f1d07a1aaf324817ee993aab7aee9db47ceac757deabafbe/kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:464415881e4801295659462c49461a24fb107c140de781d55518c4b80cb6790f", size = 78009, upload-time = "2025-08-10T21:27:46.376Z" },+ { url = "https://files.pythonhosted.org/packages/da/e9/0d4add7873a73e462aeb45c036a2dead2562b825aa46ba326727b3f31016/kiwisolver-1.4.9-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:fb940820c63a9590d31d88b815e7a3aa5915cad3ce735ab45f0c730b39547de1", size = 73929, upload-time = "2025-08-10T21:27:48.236Z" },][[package]]name = "lexid"version = "2021.1006"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/60/0b/28a3f9abc75abbf1fa996eb2dd77e1e33a5d1aac62566e3f60a8ec8b8a22/lexid-2021.1006.tar.gz", hash = "sha256:509a3a4cc926d3dbf22b203b18a4c66c25e6473fb7c0e0d30374533ac28bafe5", size = 11525 }+sdist = { url = "https://files.pythonhosted.org/packages/60/0b/28a3f9abc75abbf1fa996eb2dd77e1e33a5d1aac62566e3f60a8ec8b8a22/lexid-2021.1006.tar.gz", hash = "sha256:509a3a4cc926d3dbf22b203b18a4c66c25e6473fb7c0e0d30374533ac28bafe5", size = 11525, upload-time = "2021-04-02T20:18:34.668Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/cf/e3/35764404a4b7e2021be1f88f42264c2e92e0c4720273559a62461ce64a47/lexid-2021.1006-py2.py3-none-any.whl", hash = "sha256:5526bb5606fd74c7add23320da5f02805bddd7c77916f2dc1943e6bada8605ed", size = 7587 },+ { url = "https://files.pythonhosted.org/packages/cf/e3/35764404a4b7e2021be1f88f42264c2e92e0c4720273559a62461ce64a47/lexid-2021.1006-py2.py3-none-any.whl", hash = "sha256:5526bb5606fd74c7add23320da5f02805bddd7c77916f2dc1943e6bada8605ed", size = 7587, upload-time = "2021-04-02T20:18:33.129Z" },][[package]]name = "libsass"version = "0.23.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/79/b4/ab091585eaa77299558e3289ca206846aefc123fb320b5656ab2542c20ad/libsass-0.23.0.tar.gz", hash = "sha256:6f209955ede26684e76912caf329f4ccb57e4a043fd77fe0e7348dd9574f1880", size = 316068 }+sdist = { url = "https://files.pythonhosted.org/packages/79/b4/ab091585eaa77299558e3289ca206846aefc123fb320b5656ab2542c20ad/libsass-0.23.0.tar.gz", hash = "sha256:6f209955ede26684e76912caf329f4ccb57e4a043fd77fe0e7348dd9574f1880", size = 316068, upload-time = "2024-01-06T18:53:05.404Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/e5/13/fc1bea1de880ca935137183727c7d4dd921c4128fc08b8ddc3698ba5a8a3/libsass-0.23.0-cp38-abi3-macosx_11_0_x86_64.whl", hash = "sha256:34cae047cbbfc4ffa832a61cbb110f3c95f5471c6170c842d3fed161e40814dc", size = 1086783 },- { url = "https://files.pythonhosted.org/packages/55/2f/6af938651ff3aec0a0b00742209df1172bc297fa73531f292801693b7315/libsass-0.23.0-cp38-abi3-macosx_14_0_arm64.whl", hash = "sha256:ea97d1b45cdc2fc3590cb9d7b60f1d8915d3ce17a98c1f2d4dd47ee0d9c68ce6", size = 982759 },- { url = "https://files.pythonhosted.org/packages/fd/5a/eb5b62641df0459a3291fc206cf5bd669c0feed7814dded8edef4ade8512/libsass-0.23.0-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:4a218406d605f325d234e4678bd57126a66a88841cb95bee2caeafdc6f138306", size = 9444543 },- { url = "https://files.pythonhosted.org/packages/e5/fc/275783f5120970d859ae37d04b6a60c13bdec2aa4294b9dfa8a37b5c2513/libsass-0.23.0-cp38-abi3-win32.whl", hash = "sha256:31e86d92a5c7a551df844b72d83fc2b5e50abc6fbbb31e296f7bebd6489ed1b4", size = 775481 },- { url = "https://files.pythonhosted.org/packages/ef/20/caf3c7cf2432d85263119798c45221ddf67bdd7dae8f626d14ff8db04040/libsass-0.23.0-cp38-abi3-win_amd64.whl", hash = "sha256:a2ec85d819f353cbe807432d7275d653710d12b08ec7ef61c124a580a8352f3c", size = 872914 },+ { url = "https://files.pythonhosted.org/packages/e5/13/fc1bea1de880ca935137183727c7d4dd921c4128fc08b8ddc3698ba5a8a3/libsass-0.23.0-cp38-abi3-macosx_11_0_x86_64.whl", hash = "sha256:34cae047cbbfc4ffa832a61cbb110f3c95f5471c6170c842d3fed161e40814dc", size = 1086783, upload-time = "2024-01-06T19:02:38.903Z" },+ { url = "https://files.pythonhosted.org/packages/55/2f/6af938651ff3aec0a0b00742209df1172bc297fa73531f292801693b7315/libsass-0.23.0-cp38-abi3-macosx_14_0_arm64.whl", hash = "sha256:ea97d1b45cdc2fc3590cb9d7b60f1d8915d3ce17a98c1f2d4dd47ee0d9c68ce6", size = 982759, upload-time = "2024-01-06T19:02:41.331Z" },+ { url = "https://files.pythonhosted.org/packages/fd/5a/eb5b62641df0459a3291fc206cf5bd669c0feed7814dded8edef4ade8512/libsass-0.23.0-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:4a218406d605f325d234e4678bd57126a66a88841cb95bee2caeafdc6f138306", size = 9444543, upload-time = "2024-01-06T19:02:43.191Z" },+ { url = "https://files.pythonhosted.org/packages/e5/fc/275783f5120970d859ae37d04b6a60c13bdec2aa4294b9dfa8a37b5c2513/libsass-0.23.0-cp38-abi3-win32.whl", hash = "sha256:31e86d92a5c7a551df844b72d83fc2b5e50abc6fbbb31e296f7bebd6489ed1b4", size = 775481, upload-time = "2024-01-06T19:02:46.05Z" },+ { url = "https://files.pythonhosted.org/packages/ef/20/caf3c7cf2432d85263119798c45221ddf67bdd7dae8f626d14ff8db04040/libsass-0.23.0-cp38-abi3-win_amd64.whl", hash = "sha256:a2ec85d819f353cbe807432d7275d653710d12b08ec7ef61c124a580a8352f3c", size = 872914, upload-time = "2024-01-06T19:02:47.61Z" },][[package]]name = "llvmlite"-version = "0.45.1"+version = "0.46.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/99/8d/5baf1cef7f9c084fb35a8afbde88074f0d6a727bc63ef764fe0e7543ba40/llvmlite-0.45.1.tar.gz", hash = "sha256:09430bb9d0bb58fc45a45a57c7eae912850bedc095cd0810a57de109c69e1c32", size = 185600 }+sdist = { url = "https://files.pythonhosted.org/packages/74/cd/08ae687ba099c7e3d21fe2ea536500563ef1943c5105bf6ab4ee3829f68e/llvmlite-0.46.0.tar.gz", hash = "sha256:227c9fd6d09dce2783c18b754b7cd9d9b3b3515210c46acc2d3c5badd9870ceb", size = 193456, upload-time = "2025-12-08T18:15:36.295Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/04/ad/9bdc87b2eb34642c1cfe6bcb4f5db64c21f91f26b010f263e7467e7536a3/llvmlite-0.45.1-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:60f92868d5d3af30b4239b50e1717cb4e4e54f6ac1c361a27903b318d0f07f42", size = 43043526 },- { url = "https://files.pythonhosted.org/packages/a5/ea/c25c6382f452a943b4082da5e8c1665ce29a62884e2ec80608533e8e82d5/llvmlite-0.45.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:98baab513e19beb210f1ef39066288784839a44cd504e24fff5d17f1b3cf0860", size = 37253118 },- { url = "https://files.pythonhosted.org/packages/fe/af/85fc237de98b181dbbe8647324331238d6c52a3554327ccdc83ced28efba/llvmlite-0.45.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3adc2355694d6a6fbcc024d59bb756677e7de506037c878022d7b877e7613a36", size = 56288209 },- { url = "https://files.pythonhosted.org/packages/0a/df/3daf95302ff49beff4230065e3178cd40e71294968e8d55baf4a9e560814/llvmlite-0.45.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f3377a6db40f563058c9515dedcc8a3e562d8693a106a28f2ddccf2c8fcf6ca", size = 55140958 },- { url = "https://files.pythonhosted.org/packages/a4/56/4c0d503fe03bac820ecdeb14590cf9a248e120f483bcd5c009f2534f23f0/llvmlite-0.45.1-cp311-cp311-win_amd64.whl", hash = "sha256:f9c272682d91e0d57f2a76c6d9ebdfccc603a01828cdbe3d15273bdca0c3363a", size = 38132232 },- { url = "https://files.pythonhosted.org/packages/e2/7c/82cbd5c656e8991bcc110c69d05913be2229302a92acb96109e166ae31fb/llvmlite-0.45.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:28e763aba92fe9c72296911e040231d486447c01d4f90027c8e893d89d49b20e", size = 43043524 },- { url = "https://files.pythonhosted.org/packages/9d/bc/5314005bb2c7ee9f33102c6456c18cc81745d7055155d1218f1624463774/llvmlite-0.45.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1a53f4b74ee9fd30cb3d27d904dadece67a7575198bd80e687ee76474620735f", size = 37253123 },- { url = "https://files.pythonhosted.org/packages/96/76/0f7154952f037cb320b83e1c952ec4a19d5d689cf7d27cb8a26887d7bbc1/llvmlite-0.45.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b3796b1b1e1c14dcae34285d2f4ea488402fbd2c400ccf7137603ca3800864f", size = 56288211 },- { url = "https://files.pythonhosted.org/packages/00/b1/0b581942be2683ceb6862d558979e87387e14ad65a1e4db0e7dd671fa315/llvmlite-0.45.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:779e2f2ceefef0f4368548685f0b4adde34e5f4b457e90391f570a10b348d433", size = 55140958 },- { url = "https://files.pythonhosted.org/packages/33/94/9ba4ebcf4d541a325fd8098ddc073b663af75cc8b065b6059848f7d4dce7/llvmlite-0.45.1-cp312-cp312-win_amd64.whl", hash = "sha256:9e6c9949baf25d9aa9cd7cf0f6d011b9ca660dd17f5ba2b23bdbdb77cc86b116", size = 38132231 },- { url = "https://files.pythonhosted.org/packages/1d/e2/c185bb7e88514d5025f93c6c4092f6120c6cea8fe938974ec9860fb03bbb/llvmlite-0.45.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:d9ea9e6f17569a4253515cc01dade70aba536476e3d750b2e18d81d7e670eb15", size = 43043524 },- { url = "https://files.pythonhosted.org/packages/09/b8/b5437b9ecb2064e89ccf67dccae0d02cd38911705112dd0dcbfa9cd9a9de/llvmlite-0.45.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:c9f3cadee1630ce4ac18ea38adebf2a4f57a89bd2740ce83746876797f6e0bfb", size = 37253121 },- { url = "https://files.pythonhosted.org/packages/f7/97/ad1a907c0173a90dd4df7228f24a3ec61058bc1a9ff8a0caec20a0cc622e/llvmlite-0.45.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:57c48bf2e1083eedbc9406fb83c4e6483017879714916fe8be8a72a9672c995a", size = 56288210 },- { url = "https://files.pythonhosted.org/packages/32/d8/c99c8ac7a326e9735401ead3116f7685a7ec652691aeb2615aa732b1fc4a/llvmlite-0.45.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3aa3dfceda4219ae39cf18806c60eeb518c1680ff834b8b311bd784160b9ce40", size = 55140957 },- { url = "https://files.pythonhosted.org/packages/09/56/ed35668130e32dbfad2eb37356793b0a95f23494ab5be7d9bf5cb75850ee/llvmlite-0.45.1-cp313-cp313-win_amd64.whl", hash = "sha256:080e6f8d0778a8239cd47686d402cb66eb165e421efa9391366a9b7e5810a38b", size = 38132232 },+ { url = "https://files.pythonhosted.org/packages/7a/a1/2ad4b2367915faeebe8447f0a057861f646dbf5fbbb3561db42c65659cf3/llvmlite-0.46.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:82f3d39b16f19aa1a56d5fe625883a6ab600d5cc9ea8906cca70ce94cabba067", size = 37232766, upload-time = "2025-12-08T18:14:48.836Z" },+ { url = "https://files.pythonhosted.org/packages/12/b5/99cf8772fdd846c07da4fd70f07812a3c8fd17ea2409522c946bb0f2b277/llvmlite-0.46.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a3df43900119803bbc52720e758c76f316a9a0f34612a886862dfe0a5591a17e", size = 56275175, upload-time = "2025-12-08T18:14:51.604Z" },+ { url = "https://files.pythonhosted.org/packages/38/f2/ed806f9c003563732da156139c45d970ee435bd0bfa5ed8de87ba972b452/llvmlite-0.46.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de183fefc8022d21b0aa37fc3e90410bc3524aed8617f0ff76732fc6c3af5361", size = 55128630, upload-time = "2025-12-08T18:14:55.107Z" },+ { url = "https://files.pythonhosted.org/packages/19/0c/8f5a37a65fc9b7b17408508145edd5f86263ad69c19d3574e818f533a0eb/llvmlite-0.46.0-cp311-cp311-win_amd64.whl", hash = "sha256:e8b10bc585c58bdffec9e0c309bb7d51be1f2f15e169a4b4d42f2389e431eb93", size = 38138652, upload-time = "2025-12-08T18:14:58.171Z" },+ { url = "https://files.pythonhosted.org/packages/2b/f8/4db016a5e547d4e054ff2f3b99203d63a497465f81ab78ec8eb2ff7b2304/llvmlite-0.46.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b9588ad4c63b4f0175a3984b85494f0c927c6b001e3a246a3a7fb3920d9a137", size = 37232767, upload-time = "2025-12-08T18:15:00.737Z" },+ { url = "https://files.pythonhosted.org/packages/aa/85/4890a7c14b4fa54400945cb52ac3cd88545bbdb973c440f98ca41591cdc5/llvmlite-0.46.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3535bd2bb6a2d7ae4012681ac228e5132cdb75fefb1bcb24e33f2f3e0c865ed4", size = 56275176, upload-time = "2025-12-08T18:15:03.936Z" },+ { url = "https://files.pythonhosted.org/packages/6a/07/3d31d39c1a1a08cd5337e78299fca77e6aebc07c059fbd0033e3edfab45c/llvmlite-0.46.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4cbfd366e60ff87ea6cc62f50bc4cd800ebb13ed4c149466f50cf2163a473d1e", size = 55128630, upload-time = "2025-12-08T18:15:07.196Z" },+ { url = "https://files.pythonhosted.org/packages/2a/6b/d139535d7590a1bba1ceb68751bef22fadaa5b815bbdf0e858e3875726b2/llvmlite-0.46.0-cp312-cp312-win_amd64.whl", hash = "sha256:398b39db462c39563a97b912d4f2866cd37cba60537975a09679b28fbbc0fb38", size = 38138940, upload-time = "2025-12-08T18:15:10.162Z" },+ { url = "https://files.pythonhosted.org/packages/e6/ff/3eba7eb0aed4b6fca37125387cd417e8c458e750621fce56d2c541f67fa8/llvmlite-0.46.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:30b60892d034bc560e0ec6654737aaa74e5ca327bd8114d82136aa071d611172", size = 37232767, upload-time = "2025-12-08T18:15:13.22Z" },+ { url = "https://files.pythonhosted.org/packages/0e/54/737755c0a91558364b9200702c3c9c15d70ed63f9b98a2c32f1c2aa1f3ba/llvmlite-0.46.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6cc19b051753368a9c9f31dc041299059ee91aceec81bd57b0e385e5d5bf1a54", size = 56275176, upload-time = "2025-12-08T18:15:16.339Z" },+ { url = "https://files.pythonhosted.org/packages/e6/91/14f32e1d70905c1c0aa4e6609ab5d705c3183116ca02ac6df2091868413a/llvmlite-0.46.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bca185892908f9ede48c0acd547fe4dc1bafefb8a4967d47db6cf664f9332d12", size = 55128629, upload-time = "2025-12-08T18:15:19.493Z" },+ { url = "https://files.pythonhosted.org/packages/4a/a7/d526ae86708cea531935ae777b6dbcabe7db52718e6401e0fb9c5edea80e/llvmlite-0.46.0-cp313-cp313-win_amd64.whl", hash = "sha256:67438fd30e12349ebb054d86a5a1a57fd5e87d264d2451bcfafbbbaa25b82a35", size = 38138941, upload-time = "2025-12-08T18:15:22.536Z" },+ { url = "https://files.pythonhosted.org/packages/95/ae/af0ffb724814cc2ea64445acad05f71cff5f799bb7efb22e47ee99340dbc/llvmlite-0.46.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:d252edfb9f4ac1fcf20652258e3f102b26b03eef738dc8a6ffdab7d7d341d547", size = 37232768, upload-time = "2025-12-08T18:15:25.055Z" },+ { url = "https://files.pythonhosted.org/packages/c9/19/5018e5352019be753b7b07f7759cdabb69ca5779fea2494be8839270df4c/llvmlite-0.46.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:379fdd1c59badeff8982cb47e4694a6143bec3bb49aa10a466e095410522064d", size = 56275173, upload-time = "2025-12-08T18:15:28.109Z" },+ { url = "https://files.pythonhosted.org/packages/9f/c9/d57877759d707e84c082163c543853245f91b70c804115a5010532890f18/llvmlite-0.46.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e8cbfff7f6db0fa2c771ad24154e2a7e457c2444d7673e6de06b8b698c3b269", size = 55128628, upload-time = "2025-12-08T18:15:31.098Z" },+ { url = "https://files.pythonhosted.org/packages/30/a8/e61a8c2b3cc7a597073d9cde1fcbb567e9d827f1db30c93cf80422eac70d/llvmlite-0.46.0-cp314-cp314-win_amd64.whl", hash = "sha256:7821eda3ec1f18050f981819756631d60b6d7ab1a6cf806d9efefbe3f4082d61", size = 39153056, upload-time = "2025-12-08T18:15:33.938Z" },][[package]]name = "macholib"-version = "1.16.3"+version = "1.16.4"source = { registry = "https://pypi.org/simple" }dependencies = [- { name = "altgraph" },+ { name = "altgraph", marker = "sys_platform == 'darwin'" },]-sdist = { url = "https://files.pythonhosted.org/packages/95/ee/af1a3842bdd5902ce133bd246eb7ffd4375c38642aeb5dc0ae3a0329dfa2/macholib-1.16.3.tar.gz", hash = "sha256:07ae9e15e8e4cd9a788013d81f5908b3609aa76f9b1421bae9c4d7606ec86a30", size = 59309 }+sdist = { url = "https://files.pythonhosted.org/packages/10/2f/97589876ea967487978071c9042518d28b958d87b17dceb7cdc1d881f963/macholib-1.16.4.tar.gz", hash = "sha256:f408c93ab2e995cd2c46e34fe328b130404be143469e41bc366c807448979362", size = 59427, upload-time = "2025-11-22T08:28:38.373Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/d1/5d/c059c180c84f7962db0aeae7c3b9303ed1d73d76f2bfbc32bc231c8be314/macholib-1.16.3-py2.py3-none-any.whl", hash = "sha256:0e315d7583d38b8c77e815b1ecbdbf504a8258d8b3e17b61165c6feb60d18f2c", size = 38094 },+ { url = "https://files.pythonhosted.org/packages/c7/d1/a9f36f8ecdf0fb7c9b1e78c8d7af12b8c8754e74851ac7b94a8305540fc7/macholib-1.16.4-py2.py3-none-any.whl", hash = "sha256:da1a3fa8266e30f0ce7e97c6a54eefaae8edd1e5f86f3eb8b95457cae90265ea", size = 38117, upload-time = "2025-11-22T08:28:36.939Z" },][[package]]@@ -846,14 +762,14 @@ source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "mdurl" },]-sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070 }+sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321 },+ { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" },][[package]]name = "matplotlib"-version = "3.10.7"+version = "3.10.8"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "contourpy" },@@ -866,213 +782,138 @@ dependencies = [{ name = "pyparsing" },{ name = "python-dateutil" },]-sdist = { url = "https://files.pythonhosted.org/packages/ae/e2/d2d5295be2f44c678ebaf3544ba32d20c1f9ef08c49fe47f496180e1db15/matplotlib-3.10.7.tar.gz", hash = "sha256:a06ba7e2a2ef9131c79c49e63dad355d2d878413a0376c1727c8b9335ff731c7", size = 34804865 }-wheels = [- { url = "https://files.pythonhosted.org/packages/fc/bc/0fb489005669127ec13f51be0c6adc074d7cf191075dab1da9fe3b7a3cfc/matplotlib-3.10.7-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:53b492410a6cd66c7a471de6c924f6ede976e963c0f3097a3b7abfadddc67d0a", size = 8257507 },- { url = "https://files.pythonhosted.org/packages/e2/6a/d42588ad895279ff6708924645b5d2ed54a7fb2dc045c8a804e955aeace1/matplotlib-3.10.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d9749313deb729f08207718d29c86246beb2ea3fdba753595b55901dee5d2fd6", size = 8119565 },- { url = "https://files.pythonhosted.org/packages/10/b7/4aa196155b4d846bd749cf82aa5a4c300cf55a8b5e0dfa5b722a63c0f8a0/matplotlib-3.10.7-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2222c7ba2cbde7fe63032769f6eb7e83ab3227f47d997a8453377709b7fe3a5a", size = 8692668 },- { url = "https://files.pythonhosted.org/packages/e6/e7/664d2b97016f46683a02d854d730cfcf54ff92c1dafa424beebef50f831d/matplotlib-3.10.7-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e91f61a064c92c307c5a9dc8c05dc9f8a68f0a3be199d9a002a0622e13f874a1", size = 9521051 },- { url = "https://files.pythonhosted.org/packages/a8/a3/37aef1404efa615f49b5758a5e0261c16dd88f389bc1861e722620e4a754/matplotlib-3.10.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6f1851eab59ca082c95df5a500106bad73672645625e04538b3ad0f69471ffcc", size = 9576878 },- { url = "https://files.pythonhosted.org/packages/33/cd/b145f9797126f3f809d177ca378de57c45413c5099c5990de2658760594a/matplotlib-3.10.7-cp311-cp311-win_amd64.whl", hash = "sha256:6516ce375109c60ceec579e699524e9d504cd7578506f01150f7a6bc174a775e", size = 8115142 },- { url = "https://files.pythonhosted.org/packages/2e/39/63bca9d2b78455ed497fcf51a9c71df200a11048f48249038f06447fa947/matplotlib-3.10.7-cp311-cp311-win_arm64.whl", hash = "sha256:b172db79759f5f9bc13ef1c3ef8b9ee7b37b0247f987fbbbdaa15e4f87fd46a9", size = 7992439 },- { url = "https://files.pythonhosted.org/packages/be/b3/09eb0f7796932826ec20c25b517d568627754f6c6462fca19e12c02f2e12/matplotlib-3.10.7-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7a0edb7209e21840e8361e91ea84ea676658aa93edd5f8762793dec77a4a6748", size = 8272389 },- { url = "https://files.pythonhosted.org/packages/11/0b/1ae80ddafb8652fd8046cb5c8460ecc8d4afccb89e2c6d6bec61e04e1eaf/matplotlib-3.10.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c380371d3c23e0eadf8ebff114445b9f970aff2010198d498d4ab4c3b41eea4f", size = 8128247 },- { url = "https://files.pythonhosted.org/packages/7d/18/95ae2e242d4a5c98bd6e90e36e128d71cf1c7e39b0874feaed3ef782e789/matplotlib-3.10.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d5f256d49fea31f40f166a5e3131235a5d2f4b7f44520b1cf0baf1ce568ccff0", size = 8696996 },- { url = "https://files.pythonhosted.org/packages/7e/3d/5b559efc800bd05cb2033aa85f7e13af51958136a48327f7c261801ff90a/matplotlib-3.10.7-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:11ae579ac83cdf3fb72573bb89f70e0534de05266728740d478f0f818983c695", size = 9530153 },- { url = "https://files.pythonhosted.org/packages/88/57/eab4a719fd110312d3c220595d63a3c85ec2a39723f0f4e7fa7e6e3f74ba/matplotlib-3.10.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4c14b6acd16cddc3569a2d515cfdd81c7a68ac5639b76548cfc1a9e48b20eb65", size = 9593093 },- { url = "https://files.pythonhosted.org/packages/31/3c/80816f027b3a4a28cd2a0a6ef7f89a2db22310e945cd886ec25bfb399221/matplotlib-3.10.7-cp312-cp312-win_amd64.whl", hash = "sha256:0d8c32b7ea6fb80b1aeff5a2ceb3fb9778e2759e899d9beff75584714afcc5ee", size = 8122771 },- { url = "https://files.pythonhosted.org/packages/de/77/ef1fc78bfe99999b2675435cc52120887191c566b25017d78beaabef7f2d/matplotlib-3.10.7-cp312-cp312-win_arm64.whl", hash = "sha256:5f3f6d315dcc176ba7ca6e74c7768fb7e4cf566c49cb143f6bc257b62e634ed8", size = 7992812 },- { url = "https://files.pythonhosted.org/packages/02/9c/207547916a02c78f6bdd83448d9b21afbc42f6379ed887ecf610984f3b4e/matplotlib-3.10.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1d9d3713a237970569156cfb4de7533b7c4eacdd61789726f444f96a0d28f57f", size = 8273212 },- { url = "https://files.pythonhosted.org/packages/bc/d0/b3d3338d467d3fc937f0bb7f256711395cae6f78e22cef0656159950adf0/matplotlib-3.10.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:37a1fea41153dd6ee061d21ab69c9cf2cf543160b1b85d89cd3d2e2a7902ca4c", size = 8128713 },- { url = "https://files.pythonhosted.org/packages/22/ff/6425bf5c20d79aa5b959d1ce9e65f599632345391381c9a104133fe0b171/matplotlib-3.10.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b3c4ea4948d93c9c29dc01c0c23eef66f2101bf75158c291b88de6525c55c3d1", size = 8698527 },- { url = "https://files.pythonhosted.org/packages/d0/7f/ccdca06f4c2e6c7989270ed7829b8679466682f4cfc0f8c9986241c023b6/matplotlib-3.10.7-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22df30ffaa89f6643206cf13877191c63a50e8f800b038bc39bee9d2d4957632", size = 9529690 },- { url = "https://files.pythonhosted.org/packages/b8/95/b80fc2c1f269f21ff3d193ca697358e24408c33ce2b106a7438a45407b63/matplotlib-3.10.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b69676845a0a66f9da30e87f48be36734d6748024b525ec4710be40194282c84", size = 9593732 },- { url = "https://files.pythonhosted.org/packages/e1/b6/23064a96308b9aeceeffa65e96bcde459a2ea4934d311dee20afde7407a0/matplotlib-3.10.7-cp313-cp313-win_amd64.whl", hash = "sha256:744991e0cc863dd669c8dc9136ca4e6e0082be2070b9d793cbd64bec872a6815", size = 8122727 },- { url = "https://files.pythonhosted.org/packages/b3/a6/2faaf48133b82cf3607759027f82b5c702aa99cdfcefb7f93d6ccf26a424/matplotlib-3.10.7-cp313-cp313-win_arm64.whl", hash = "sha256:fba2974df0bf8ce3c995fa84b79cde38326e0f7b5409e7a3a481c1141340bcf7", size = 7992958 },- { url = "https://files.pythonhosted.org/packages/4a/f0/b018fed0b599bd48d84c08794cb242227fe3341952da102ee9d9682db574/matplotlib-3.10.7-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:932c55d1fa7af4423422cb6a492a31cbcbdbe68fd1a9a3f545aa5e7a143b5355", size = 8316849 },- { url = "https://files.pythonhosted.org/packages/b0/b7/bb4f23856197659f275e11a2a164e36e65e9b48ea3e93c4ec25b4f163198/matplotlib-3.10.7-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5e38c2d581d62ee729a6e144c47a71b3f42fb4187508dbbf4fe71d5612c3433b", size = 8178225 },- { url = "https://files.pythonhosted.org/packages/62/56/0600609893ff277e6f3ab3c0cef4eafa6e61006c058e84286c467223d4d5/matplotlib-3.10.7-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:786656bb13c237bbcebcd402f65f44dd61ead60ee3deb045af429d889c8dbc67", size = 8711708 },- { url = "https://files.pythonhosted.org/packages/d8/1a/6bfecb0cafe94d6658f2f1af22c43b76cf7a1c2f0dc34ef84cbb6809617e/matplotlib-3.10.7-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09d7945a70ea43bf9248f4b6582734c2fe726723204a76eca233f24cffc7ef67", size = 9541409 },- { url = "https://files.pythonhosted.org/packages/08/50/95122a407d7f2e446fd865e2388a232a23f2b81934960ea802f3171518e4/matplotlib-3.10.7-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d0b181e9fa8daf1d9f2d4c547527b167cb8838fc587deabca7b5c01f97199e84", size = 9594054 },- { url = "https://files.pythonhosted.org/packages/13/76/75b194a43b81583478a81e78a07da8d9ca6ddf50dd0a2ccabf258059481d/matplotlib-3.10.7-cp313-cp313t-win_amd64.whl", hash = "sha256:31963603041634ce1a96053047b40961f7a29eb8f9a62e80cc2c0427aa1d22a2", size = 8200100 },- { url = "https://files.pythonhosted.org/packages/f5/9e/6aefebdc9f8235c12bdeeda44cc0383d89c1e41da2c400caf3ee2073a3ce/matplotlib-3.10.7-cp313-cp313t-win_arm64.whl", hash = "sha256:aebed7b50aa6ac698c90f60f854b47e48cd2252b30510e7a1feddaf5a3f72cbf", size = 8042131 },- { url = "https://files.pythonhosted.org/packages/0d/4b/e5bc2c321b6a7e3a75638d937d19ea267c34bd5a90e12bee76c4d7c7a0d9/matplotlib-3.10.7-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d883460c43e8c6b173fef244a2341f7f7c0e9725c7fe68306e8e44ed9c8fb100", size = 8273787 },- { url = "https://files.pythonhosted.org/packages/86/ad/6efae459c56c2fbc404da154e13e3a6039129f3c942b0152624f1c621f05/matplotlib-3.10.7-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:07124afcf7a6504eafcb8ce94091c5898bbdd351519a1beb5c45f7a38c67e77f", size = 8131348 },- { url = "https://files.pythonhosted.org/packages/a6/5a/a4284d2958dee4116359cc05d7e19c057e64ece1b4ac986ab0f2f4d52d5a/matplotlib-3.10.7-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c17398b709a6cce3d9fdb1595c33e356d91c098cd9486cb2cc21ea2ea418e715", size = 9533949 },- { url = "https://files.pythonhosted.org/packages/de/ff/f3781b5057fa3786623ad8976fc9f7b0d02b2f28534751fd5a44240de4cf/matplotlib-3.10.7-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7146d64f561498764561e9cd0ed64fcf582e570fc519e6f521e2d0cfd43365e1", size = 9804247 },- { url = "https://files.pythonhosted.org/packages/47/5a/993a59facb8444efb0e197bf55f545ee449902dcee86a4dfc580c3b61314/matplotlib-3.10.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90ad854c0a435da3104c01e2c6f0028d7e719b690998a2333d7218db80950722", size = 9595497 },- { url = "https://files.pythonhosted.org/packages/0d/a5/77c95aaa9bb32c345cbb49626ad8eb15550cba2e6d4c88081a6c2ac7b08d/matplotlib-3.10.7-cp314-cp314-win_amd64.whl", hash = "sha256:4645fc5d9d20ffa3a39361fcdbcec731382763b623b72627806bf251b6388866", size = 8252732 },- { url = "https://files.pythonhosted.org/packages/74/04/45d269b4268d222390d7817dae77b159651909669a34ee9fdee336db5883/matplotlib-3.10.7-cp314-cp314-win_arm64.whl", hash = "sha256:9257be2f2a03415f9105c486d304a321168e61ad450f6153d77c69504ad764bb", size = 8124240 },- { url = "https://files.pythonhosted.org/packages/4b/c7/ca01c607bb827158b439208c153d6f14ddb9fb640768f06f7ca3488ae67b/matplotlib-3.10.7-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1e4bbad66c177a8fdfa53972e5ef8be72a5f27e6a607cec0d8579abd0f3102b1", size = 8316938 },- { url = "https://files.pythonhosted.org/packages/84/d2/5539e66e9f56d2fdec94bb8436f5e449683b4e199bcc897c44fbe3c99e28/matplotlib-3.10.7-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d8eb7194b084b12feb19142262165832fc6ee879b945491d1c3d4660748020c4", size = 8178245 },- { url = "https://files.pythonhosted.org/packages/77/b5/e6ca22901fd3e4fe433a82e583436dd872f6c966fca7e63cf806b40356f8/matplotlib-3.10.7-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4d41379b05528091f00e1728004f9a8d7191260f3862178b88e8fd770206318", size = 9541411 },- { url = "https://files.pythonhosted.org/packages/9e/99/a4524db57cad8fee54b7237239a8f8360bfcfa3170d37c9e71c090c0f409/matplotlib-3.10.7-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4a74f79fafb2e177f240579bc83f0b60f82cc47d2f1d260f422a0627207008ca", size = 9803664 },- { url = "https://files.pythonhosted.org/packages/e6/a5/85e2edf76ea0ad4288d174926d9454ea85f3ce5390cc4e6fab196cbf250b/matplotlib-3.10.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:702590829c30aada1e8cef0568ddbffa77ca747b4d6e36c6d173f66e301f89cc", size = 9594066 },- { url = "https://files.pythonhosted.org/packages/39/69/9684368a314f6d83fe5c5ad2a4121a3a8e03723d2e5c8ea17b66c1bad0e7/matplotlib-3.10.7-cp314-cp314t-win_amd64.whl", hash = "sha256:f79d5de970fc90cd5591f60053aecfce1fcd736e0303d9f0bf86be649fa68fb8", size = 8342832 },- { url = "https://files.pythonhosted.org/packages/04/5f/e22e08da14bc1a0894184640d47819d2338b792732e20d292bf86e5ab785/matplotlib-3.10.7-cp314-cp314t-win_arm64.whl", hash = "sha256:cb783436e47fcf82064baca52ce748af71725d0352e1d31564cbe9c95df92b9c", size = 8172585 },- { url = "https://files.pythonhosted.org/packages/58/8f/76d5dc21ac64a49e5498d7f0472c0781dae442dd266a67458baec38288ec/matplotlib-3.10.7-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:15112bcbaef211bd663fa935ec33313b948e214454d949b723998a43357b17b0", size = 8252283 },- { url = "https://files.pythonhosted.org/packages/27/0d/9c5d4c2317feb31d819e38c9f947c942f42ebd4eb935fc6fd3518a11eaa7/matplotlib-3.10.7-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d2a959c640cdeecdd2ec3136e8ea0441da59bcaf58d67e9c590740addba2cb68", size = 8116733 },- { url = "https://files.pythonhosted.org/packages/9a/cc/3fe688ff1355010937713164caacf9ed443675ac48a997bab6ed23b3f7c0/matplotlib-3.10.7-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3886e47f64611046bc1db523a09dd0a0a6bed6081e6f90e13806dd1d1d1b5e91", size = 8693919 },+sdist = { url = "https://files.pythonhosted.org/packages/8a/76/d3c6e3a13fe484ebe7718d14e269c9569c4eb0020a968a327acb3b9a8fe6/matplotlib-3.10.8.tar.gz", hash = "sha256:2299372c19d56bcd35cf05a2738308758d32b9eaed2371898d8f5bd33f084aa3", size = 34806269, upload-time = "2025-12-10T22:56:51.155Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/f8/86/de7e3a1cdcfc941483af70609edc06b83e7c8a0e0dc9ac325200a3f4d220/matplotlib-3.10.8-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6be43b667360fef5c754dda5d25a32e6307a03c204f3c0fc5468b78fa87b4160", size = 8251215, upload-time = "2025-12-10T22:55:16.175Z" },+ { url = "https://files.pythonhosted.org/packages/fd/14/baad3222f424b19ce6ad243c71de1ad9ec6b2e4eb1e458a48fdc6d120401/matplotlib-3.10.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a2b336e2d91a3d7006864e0990c83b216fcdca64b5a6484912902cef87313d78", size = 8139625, upload-time = "2025-12-10T22:55:17.712Z" },+ { url = "https://files.pythonhosted.org/packages/8f/a0/7024215e95d456de5883e6732e708d8187d9753a21d32f8ddb3befc0c445/matplotlib-3.10.8-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:efb30e3baaea72ce5928e32bab719ab4770099079d66726a62b11b1ef7273be4", size = 8712614, upload-time = "2025-12-10T22:55:20.8Z" },+ { url = "https://files.pythonhosted.org/packages/5a/f4/b8347351da9a5b3f41e26cf547252d861f685c6867d179a7c9d60ad50189/matplotlib-3.10.8-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d56a1efd5bfd61486c8bc968fa18734464556f0fb8e51690f4ac25d85cbbbbc2", size = 9540997, upload-time = "2025-12-10T22:55:23.258Z" },+ { url = "https://files.pythonhosted.org/packages/9e/c0/c7b914e297efe0bc36917bf216b2acb91044b91e930e878ae12981e461e5/matplotlib-3.10.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:238b7ce5717600615c895050239ec955d91f321c209dd110db988500558e70d6", size = 9596825, upload-time = "2025-12-10T22:55:25.217Z" },+ { url = "https://files.pythonhosted.org/packages/6f/d3/a4bbc01c237ab710a1f22b4da72f4ff6d77eb4c7735ea9811a94ae239067/matplotlib-3.10.8-cp311-cp311-win_amd64.whl", hash = "sha256:18821ace09c763ec93aef5eeff087ee493a24051936d7b9ebcad9662f66501f9", size = 8135090, upload-time = "2025-12-10T22:55:27.162Z" },+ { url = "https://files.pythonhosted.org/packages/89/dd/a0b6588f102beab33ca6f5218b31725216577b2a24172f327eaf6417d5c9/matplotlib-3.10.8-cp311-cp311-win_arm64.whl", hash = "sha256:bab485bcf8b1c7d2060b4fcb6fc368a9e6f4cd754c9c2fea281f4be21df394a2", size = 8012377, upload-time = "2025-12-10T22:55:29.185Z" },+ { url = "https://files.pythonhosted.org/packages/9e/67/f997cdcbb514012eb0d10cd2b4b332667997fb5ebe26b8d41d04962fa0e6/matplotlib-3.10.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:64fcc24778ca0404ce0cb7b6b77ae1f4c7231cdd60e6778f999ee05cbd581b9a", size = 8260453, upload-time = "2025-12-10T22:55:30.709Z" },+ { url = "https://files.pythonhosted.org/packages/7e/65/07d5f5c7f7c994f12c768708bd2e17a4f01a2b0f44a1c9eccad872433e2e/matplotlib-3.10.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b9a5ca4ac220a0cdd1ba6bcba3608547117d30468fefce49bb26f55c1a3d5c58", size = 8148321, upload-time = "2025-12-10T22:55:33.265Z" },+ { url = "https://files.pythonhosted.org/packages/3e/f3/c5195b1ae57ef85339fd7285dfb603b22c8b4e79114bae5f4f0fcf688677/matplotlib-3.10.8-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3ab4aabc72de4ff77b3ec33a6d78a68227bf1123465887f9905ba79184a1cc04", size = 8716944, upload-time = "2025-12-10T22:55:34.922Z" },+ { url = "https://files.pythonhosted.org/packages/00/f9/7638f5cc82ec8a7aa005de48622eecc3ed7c9854b96ba15bd76b7fd27574/matplotlib-3.10.8-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:24d50994d8c5816ddc35411e50a86ab05f575e2530c02752e02538122613371f", size = 9550099, upload-time = "2025-12-10T22:55:36.789Z" },+ { url = "https://files.pythonhosted.org/packages/57/61/78cd5920d35b29fd2a0fe894de8adf672ff52939d2e9b43cb83cd5ce1bc7/matplotlib-3.10.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:99eefd13c0dc3b3c1b4d561c1169e65fe47aab7b8158754d7c084088e2329466", size = 9613040, upload-time = "2025-12-10T22:55:38.715Z" },+ { url = "https://files.pythonhosted.org/packages/30/4e/c10f171b6e2f44d9e3a2b96efa38b1677439d79c99357600a62cc1e9594e/matplotlib-3.10.8-cp312-cp312-win_amd64.whl", hash = "sha256:dd80ecb295460a5d9d260df63c43f4afbdd832d725a531f008dad1664f458adf", size = 8142717, upload-time = "2025-12-10T22:55:41.103Z" },+ { url = "https://files.pythonhosted.org/packages/f1/76/934db220026b5fef85f45d51a738b91dea7d70207581063cd9bd8fafcf74/matplotlib-3.10.8-cp312-cp312-win_arm64.whl", hash = "sha256:3c624e43ed56313651bc18a47f838b60d7b8032ed348911c54906b130b20071b", size = 8012751, upload-time = "2025-12-10T22:55:42.684Z" },+ { url = "https://files.pythonhosted.org/packages/3d/b9/15fd5541ef4f5b9a17eefd379356cf12175fe577424e7b1d80676516031a/matplotlib-3.10.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3f2e409836d7f5ac2f1c013110a4d50b9f7edc26328c108915f9075d7d7a91b6", size = 8261076, upload-time = "2025-12-10T22:55:44.648Z" },+ { url = "https://files.pythonhosted.org/packages/8d/a0/2ba3473c1b66b9c74dc7107c67e9008cb1782edbe896d4c899d39ae9cf78/matplotlib-3.10.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56271f3dac49a88d7fca5060f004d9d22b865f743a12a23b1e937a0be4818ee1", size = 8148794, upload-time = "2025-12-10T22:55:46.252Z" },+ { url = "https://files.pythonhosted.org/packages/75/97/a471f1c3eb1fd6f6c24a31a5858f443891d5127e63a7788678d14e249aea/matplotlib-3.10.8-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a0a7f52498f72f13d4a25ea70f35f4cb60642b466cbb0a9be951b5bc3f45a486", size = 8718474, upload-time = "2025-12-10T22:55:47.864Z" },+ { url = "https://files.pythonhosted.org/packages/01/be/cd478f4b66f48256f42927d0acbcd63a26a893136456cd079c0cc24fbabf/matplotlib-3.10.8-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:646d95230efb9ca614a7a594d4fcacde0ac61d25e37dd51710b36477594963ce", size = 9549637, upload-time = "2025-12-10T22:55:50.048Z" },+ { url = "https://files.pythonhosted.org/packages/5d/7c/8dc289776eae5109e268c4fb92baf870678dc048a25d4ac903683b86d5bf/matplotlib-3.10.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f89c151aab2e2e23cb3fe0acad1e8b82841fd265379c4cecd0f3fcb34c15e0f6", size = 9613678, upload-time = "2025-12-10T22:55:52.21Z" },+ { url = "https://files.pythonhosted.org/packages/64/40/37612487cc8a437d4dd261b32ca21fe2d79510fe74af74e1f42becb1bdb8/matplotlib-3.10.8-cp313-cp313-win_amd64.whl", hash = "sha256:e8ea3e2d4066083e264e75c829078f9e149fa119d27e19acd503de65e0b13149", size = 8142686, upload-time = "2025-12-10T22:55:54.253Z" },+ { url = "https://files.pythonhosted.org/packages/66/52/8d8a8730e968185514680c2a6625943f70269509c3dcfc0dcf7d75928cb8/matplotlib-3.10.8-cp313-cp313-win_arm64.whl", hash = "sha256:c108a1d6fa78a50646029cb6d49808ff0fc1330fda87fa6f6250c6b5369b6645", size = 8012917, upload-time = "2025-12-10T22:55:56.268Z" },+ { url = "https://files.pythonhosted.org/packages/b5/27/51fe26e1062f298af5ef66343d8ef460e090a27fea73036c76c35821df04/matplotlib-3.10.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:ad3d9833a64cf48cc4300f2b406c3d0f4f4724a91c0bd5640678a6ba7c102077", size = 8305679, upload-time = "2025-12-10T22:55:57.856Z" },+ { url = "https://files.pythonhosted.org/packages/2c/1e/4de865bc591ac8e3062e835f42dd7fe7a93168d519557837f0e37513f629/matplotlib-3.10.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:eb3823f11823deade26ce3b9f40dcb4a213da7a670013929f31d5f5ed1055b22", size = 8198336, upload-time = "2025-12-10T22:55:59.371Z" },+ { url = "https://files.pythonhosted.org/packages/c6/cb/2f7b6e75fb4dce87ef91f60cac4f6e34f4c145ab036a22318ec837971300/matplotlib-3.10.8-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d9050fee89a89ed57b4fb2c1bfac9a3d0c57a0d55aed95949eedbc42070fea39", size = 8731653, upload-time = "2025-12-10T22:56:01.032Z" },+ { url = "https://files.pythonhosted.org/packages/46/b3/bd9c57d6ba670a37ab31fb87ec3e8691b947134b201f881665b28cc039ff/matplotlib-3.10.8-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b44d07310e404ba95f8c25aa5536f154c0a8ec473303535949e52eb71d0a1565", size = 9561356, upload-time = "2025-12-10T22:56:02.95Z" },+ { url = "https://files.pythonhosted.org/packages/c0/3d/8b94a481456dfc9dfe6e39e93b5ab376e50998cddfd23f4ae3b431708f16/matplotlib-3.10.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0a33deb84c15ede243aead39f77e990469fff93ad1521163305095b77b72ce4a", size = 9614000, upload-time = "2025-12-10T22:56:05.411Z" },+ { url = "https://files.pythonhosted.org/packages/bd/cd/bc06149fe5585ba800b189a6a654a75f1f127e8aab02fd2be10df7fa500c/matplotlib-3.10.8-cp313-cp313t-win_amd64.whl", hash = "sha256:3a48a78d2786784cc2413e57397981fb45c79e968d99656706018d6e62e57958", size = 8220043, upload-time = "2025-12-10T22:56:07.551Z" },+ { url = "https://files.pythonhosted.org/packages/e3/de/b22cf255abec916562cc04eef457c13e58a1990048de0c0c3604d082355e/matplotlib-3.10.8-cp313-cp313t-win_arm64.whl", hash = "sha256:15d30132718972c2c074cd14638c7f4592bd98719e2308bccea40e0538bc0cb5", size = 8062075, upload-time = "2025-12-10T22:56:09.178Z" },+ { url = "https://files.pythonhosted.org/packages/3c/43/9c0ff7a2f11615e516c3b058e1e6e8f9614ddeca53faca06da267c48345d/matplotlib-3.10.8-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b53285e65d4fa4c86399979e956235deb900be5baa7fc1218ea67fbfaeaadd6f", size = 8262481, upload-time = "2025-12-10T22:56:10.885Z" },+ { url = "https://files.pythonhosted.org/packages/6f/ca/e8ae28649fcdf039fda5ef554b40a95f50592a3c47e6f7270c9561c12b07/matplotlib-3.10.8-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:32f8dce744be5569bebe789e46727946041199030db8aeb2954d26013a0eb26b", size = 8151473, upload-time = "2025-12-10T22:56:12.377Z" },+ { url = "https://files.pythonhosted.org/packages/f1/6f/009d129ae70b75e88cbe7e503a12a4c0670e08ed748a902c2568909e9eb5/matplotlib-3.10.8-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4cf267add95b1c88300d96ca837833d4112756045364f5c734a2276038dae27d", size = 9553896, upload-time = "2025-12-10T22:56:14.432Z" },+ { url = "https://files.pythonhosted.org/packages/f5/26/4221a741eb97967bc1fd5e4c52b9aa5a91b2f4ec05b59f6def4d820f9df9/matplotlib-3.10.8-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2cf5bd12cecf46908f286d7838b2abc6c91cda506c0445b8223a7c19a00df008", size = 9824193, upload-time = "2025-12-10T22:56:16.29Z" },+ { url = "https://files.pythonhosted.org/packages/1f/f3/3abf75f38605772cf48a9daf5821cd4f563472f38b4b828c6fba6fa6d06e/matplotlib-3.10.8-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:41703cc95688f2516b480f7f339d8851a6035f18e100ee6a32bc0b8536a12a9c", size = 9615444, upload-time = "2025-12-10T22:56:18.155Z" },+ { url = "https://files.pythonhosted.org/packages/93/a5/de89ac80f10b8dc615807ee1133cd99ac74082581196d4d9590bea10690d/matplotlib-3.10.8-cp314-cp314-win_amd64.whl", hash = "sha256:83d282364ea9f3e52363da262ce32a09dfe241e4080dcedda3c0db059d3c1f11", size = 8272719, upload-time = "2025-12-10T22:56:20.366Z" },+ { url = "https://files.pythonhosted.org/packages/69/ce/b006495c19ccc0a137b48083168a37bd056392dee02f87dba0472f2797fe/matplotlib-3.10.8-cp314-cp314-win_arm64.whl", hash = "sha256:2c1998e92cd5999e295a731bcb2911c75f597d937341f3030cc24ef2733d78a8", size = 8144205, upload-time = "2025-12-10T22:56:22.239Z" },+ { url = "https://files.pythonhosted.org/packages/68/d9/b31116a3a855bd313c6fcdb7226926d59b041f26061c6c5b1be66a08c826/matplotlib-3.10.8-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b5a2b97dbdc7d4f353ebf343744f1d1f1cca8aa8bfddb4262fcf4306c3761d50", size = 8305785, upload-time = "2025-12-10T22:56:24.218Z" },+ { url = "https://files.pythonhosted.org/packages/1e/90/6effe8103f0272685767ba5f094f453784057072f49b393e3ea178fe70a5/matplotlib-3.10.8-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3f5c3e4da343bba819f0234186b9004faba952cc420fbc522dc4e103c1985908", size = 8198361, upload-time = "2025-12-10T22:56:26.787Z" },+ { url = "https://files.pythonhosted.org/packages/d7/65/a73188711bea603615fc0baecca1061429ac16940e2385433cc778a9d8e7/matplotlib-3.10.8-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f62550b9a30afde8c1c3ae450e5eb547d579dd69b25c2fc7a1c67f934c1717a", size = 9561357, upload-time = "2025-12-10T22:56:28.953Z" },+ { url = "https://files.pythonhosted.org/packages/f4/3d/b5c5d5d5be8ce63292567f0e2c43dde9953d3ed86ac2de0a72e93c8f07a1/matplotlib-3.10.8-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:495672de149445ec1b772ff2c9ede9b769e3cb4f0d0aa7fa730d7f59e2d4e1c1", size = 9823610, upload-time = "2025-12-10T22:56:31.455Z" },+ { url = "https://files.pythonhosted.org/packages/4d/4b/e7beb6bbd49f6bae727a12b270a2654d13c397576d25bd6786e47033300f/matplotlib-3.10.8-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:595ba4d8fe983b88f0eec8c26a241e16d6376fe1979086232f481f8f3f67494c", size = 9614011, upload-time = "2025-12-10T22:56:33.85Z" },+ { url = "https://files.pythonhosted.org/packages/7c/e6/76f2813d31f032e65f6f797e3f2f6e4aab95b65015924b1c51370395c28a/matplotlib-3.10.8-cp314-cp314t-win_amd64.whl", hash = "sha256:25d380fe8b1dc32cf8f0b1b448470a77afb195438bafdf1d858bfb876f3edf7b", size = 8362801, upload-time = "2025-12-10T22:56:36.107Z" },+ { url = "https://files.pythonhosted.org/packages/5d/49/d651878698a0b67f23aa28e17f45a6d6dd3d3f933fa29087fa4ce5947b5a/matplotlib-3.10.8-cp314-cp314t-win_arm64.whl", hash = "sha256:113bb52413ea508ce954a02c10ffd0d565f9c3bc7f2eddc27dfe1731e71c7b5f", size = 8192560, upload-time = "2025-12-10T22:56:38.008Z" },+ { url = "https://files.pythonhosted.org/packages/04/30/3afaa31c757f34b7725ab9d2ba8b48b5e89c2019c003e7d0ead143aabc5a/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:6da7c2ce169267d0d066adcf63758f0604aa6c3eebf67458930f9d9b79ad1db1", size = 8249198, upload-time = "2025-12-10T22:56:45.584Z" },+ { url = "https://files.pythonhosted.org/packages/48/2f/6334aec331f57485a642a7c8be03cb286f29111ae71c46c38b363230063c/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9153c3292705be9f9c64498a8872118540c3f4123d1a1c840172edf262c8be4a", size = 8136817, upload-time = "2025-12-10T22:56:47.339Z" },+ { url = "https://files.pythonhosted.org/packages/73/e4/6d6f14b2a759c622f191b2d67e9075a3f56aaccb3be4bb9bb6890030d0a0/matplotlib-3.10.8-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ae029229a57cd1e8fe542485f27e7ca7b23aa9e8944ddb4985d0bc444f1eca2", size = 8713867, upload-time = "2025-12-10T22:56:48.954Z" },][[package]]name = "mdurl"version = "0.1.2"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 }+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 },+ { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },][[package]]name = "mediapipe"-version = "0.10.14"+version = "0.10.32"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "absl-py" },- { name = "attrs" },{ name = "flatbuffers" },- { name = "jax", version = "0.4.29", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },- { name = "jax", version = "0.7.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },- { name = "jaxlib", version = "0.6.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.13'" },- { name = "jaxlib", version = "0.7.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.13'" },{ name = "matplotlib" },{ name = "numpy" },{ name = "opencv-contrib-python" },- { name = "protobuf" },{ name = "sounddevice" },]wheels = [- { url = "https://files.pythonhosted.org/packages/31/fb/09fde872bd3c92720860adc25ffee605f18d3a5165320ae8cd2d71da7003/mediapipe-0.10.14-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:4737fce6107bd21e420a6b2aad2c721fbc4cc318f1258b68f0665f10225bde1d", size = 50187308 },- { url = "https://files.pythonhosted.org/packages/b0/17/8e0ca5c867fe9b9943945b3a0033158fd89ae031c0a2e7dd3dd9101b2f3f/mediapipe-0.10.14-cp311-cp311-macosx_11_0_x86_64.whl", hash = "sha256:e5f8fdf512da074c225219f4e09723f612cdd3449c4793693fd360dc817c9261", size = 50098859 },- { url = "https://files.pythonhosted.org/packages/74/25/ee5679b8ddc58e97d417cfbc1c2b56346ea085a457aa61901ad225cc80bf/mediapipe-0.10.14-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1061d499d341e7f11dd7f18d5bee747e862db8ef47665ff777323282225d4315", size = 33017085 },- { url = "https://files.pythonhosted.org/packages/2f/ee/2e9e730dc4d98c8a9541b57bad173bebddf0e4c78f179acc100248c58066/mediapipe-0.10.14-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a807328339e7356fda0bb14df12fedbf1d33bdf81649c5f8666b0026b1cc30b4", size = 35664771 },- { url = "https://files.pythonhosted.org/packages/c1/0f/4dc0802131756a9fe4d46d2824352014b85a75baca386cb9e43057f39f15/mediapipe-0.10.14-cp311-cp311-win_amd64.whl", hash = "sha256:1b7687d3b63590bcc601ad195b923b80a1b2d6be5cdf43711edc661cecd3dd47", size = 50834141 },- { url = "https://files.pythonhosted.org/packages/2d/df/be410905b9757de4b00891dd34236d96e6db150b624f28cc27cd90c74564/mediapipe-0.10.14-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:aa2298c1886716cde6bd7ce96aba1505d67d52edaba856f6c2e1ab905de52b0d", size = 50203567 },- { url = "https://files.pythonhosted.org/packages/32/40/b6a2a50593e8753bf12e2dbfd130dee588eb2fc50ce74939cf6485af2756/mediapipe-0.10.14-cp312-cp312-macosx_11_0_x86_64.whl", hash = "sha256:5c97e32cbb9e9d72b78a33f011257b3cdb55b60fef70a8a864c5d2a4b6652425", size = 50117879 },- { url = "https://files.pythonhosted.org/packages/f4/da/dfed8db260b3fbe4e24ac17dda32c55787643a656d8d4e78c55bc847efa8/mediapipe-0.10.14-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e30ed2f39f925924de58adeec6a8e61ba6beb6959325dc0d8a1aa487a74377b", size = 33015939 },- { url = "https://files.pythonhosted.org/packages/11/73/07c6dcbb322f86e2b8526e0073456dbdd2813d5351f772f882123c985fda/mediapipe-0.10.14-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9b1e72d754cd9e1b4b88d80ec9ead2f1cbe8424b7f883d3bda53341b982a9f8b", size = 35665742 },- { url = "https://files.pythonhosted.org/packages/f0/26/d228fe6e9f2060dde7f7db738968bcd603e9340f064351655b5b2652a664/mediapipe-0.10.14-cp312-cp312-win_amd64.whl", hash = "sha256:ebb8350e860c8e00b7c84d71e15090fc3ac4cc9d4249892f85fb35011590e372", size = 50837898 },+ { url = "https://files.pythonhosted.org/packages/24/d9/ca1be234911c76ccd87a9e0d8210394153cb6ad9b5da65a231aff8769d6f/mediapipe-0.10.32-py3-none-macosx_11_0_arm64.whl", hash = "sha256:b62178b7585e0bb8789075c43bbb3e352fbc4a8f765797fded509f86a098b29b", size = 19386286, upload-time = "2026-01-22T16:15:01.042Z" },+ { url = "https://files.pythonhosted.org/packages/e3/98/00cd8b2dcb563f2298655633e6611a791b2c1a7df1dae064b2b96084f1bf/mediapipe-0.10.32-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:4b0941fbbbce41862f13cb1850c4878c13dbc62cd5e81e74880051b7a20ce3b6", size = 10331072, upload-time = "2026-01-22T16:15:04.747Z" },+ { url = "https://files.pythonhosted.org/packages/fe/63/c9172142521fc334fa891be9ef6259a3790502041b395127d63755cb3f0b/mediapipe-0.10.32-py3-none-win_amd64.whl", hash = "sha256:438d98977a4e1b0f88070ad16537a328912f847ce9debf236da047b0b483cbfd", size = 10211344, upload-time = "2026-01-22T16:15:11.716Z" },][[package]]-name = "ml-dtypes"-version = "0.4.1"+name = "nuitka"+version = "4.0.1"source = { registry = "https://pypi.org/simple" }-resolution-markers = [- "python_full_version >= '3.13' and platform_system == 'Darwin'",- "python_full_version >= '3.13' and platform_machine == 'aarch64' and platform_system == 'Linux'",- "(python_full_version >= '3.13' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version >= '3.13' and platform_system != 'Darwin' and platform_system != 'Linux')",-]-dependencies = [- { name = "numpy", marker = "python_full_version >= '3.13'" },-]-sdist = { url = "https://files.pythonhosted.org/packages/fd/15/76f86faa0902836cc133939732f7611ace68cf54148487a99c539c272dc8/ml_dtypes-0.4.1.tar.gz", hash = "sha256:fad5f2de464fd09127e49b7fd1252b9006fb43d2edc1ff112d390c324af5ca7a", size = 692594 }-wheels = [- { url = "https://files.pythonhosted.org/packages/d1/76/9835c8609c29f2214359e88f29255fc4aad4ea0f613fb48aa8815ceda1b6/ml_dtypes-0.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:2d55b588116a7085d6e074cf0cdb1d6fa3875c059dddc4d2c94a4cc81c23e975", size = 397973 },- { url = "https://files.pythonhosted.org/packages/7e/99/e68c56fac5de973007a10254b6e17a0362393724f40f66d5e4033f4962c2/ml_dtypes-0.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e138a9b7a48079c900ea969341a5754019a1ad17ae27ee330f7ebf43f23877f9", size = 2185134 },- { url = "https://files.pythonhosted.org/packages/28/bc/6a2344338ea7b61cd7b46fb24ec459360a5a0903b57c55b156c1e46c644a/ml_dtypes-0.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:74c6cfb5cf78535b103fde9ea3ded8e9f16f75bc07789054edc7776abfb3d752", size = 2163661 },- { url = "https://files.pythonhosted.org/packages/e8/d3/ddfd9878b223b3aa9a930c6100a99afca5cfab7ea703662e00323acb7568/ml_dtypes-0.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:274cc7193dd73b35fb26bef6c5d40ae3eb258359ee71cd82f6e96a8c948bdaa6", size = 126727 },- { url = "https://files.pythonhosted.org/packages/ba/1a/99e924f12e4b62139fbac87419698c65f956d58de0dbfa7c028fa5b096aa/ml_dtypes-0.4.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:827d3ca2097085cf0355f8fdf092b888890bb1b1455f52801a2d7756f056f54b", size = 405077 },- { url = "https://files.pythonhosted.org/packages/8f/8c/7b610bd500617854c8cc6ed7c8cfb9d48d6a5c21a1437a36a4b9bc8a3598/ml_dtypes-0.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:772426b08a6172a891274d581ce58ea2789cc8abc1c002a27223f314aaf894e7", size = 2181554 },- { url = "https://files.pythonhosted.org/packages/c7/c6/f89620cecc0581dc1839e218c4315171312e46c62a62da6ace204bda91c0/ml_dtypes-0.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:126e7d679b8676d1a958f2651949fbfa182832c3cd08020d8facd94e4114f3e9", size = 2160488 },- { url = "https://files.pythonhosted.org/packages/ae/11/a742d3c31b2cc8557a48efdde53427fd5f9caa2fa3c9c27d826e78a66f51/ml_dtypes-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:df0fb650d5c582a9e72bb5bd96cfebb2cdb889d89daff621c8fbc60295eba66c", size = 127462 },-]--[[package]]-name = "ml-dtypes"-version = "0.5.3"-source = { registry = "https://pypi.org/simple" }-resolution-markers = [- "python_full_version < '3.12' and platform_system == 'Darwin'",- "python_full_version < '3.12' and platform_machine == 'aarch64' and platform_system == 'Linux'",- "(python_full_version < '3.12' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version < '3.12' and platform_system != 'Darwin' and platform_system != 'Linux')",- "python_full_version == '3.12.*' and platform_system == 'Darwin'",- "python_full_version == '3.12.*' and platform_machine == 'aarch64' and platform_system == 'Linux'",- "(python_full_version == '3.12.*' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version == '3.12.*' and platform_system != 'Darwin' and platform_system != 'Linux')",-]-dependencies = [- { name = "numpy", marker = "python_full_version < '3.13'" },-]-sdist = { url = "https://files.pythonhosted.org/packages/78/a7/aad060393123cfb383956dca68402aff3db1e1caffd5764887ed5153f41b/ml_dtypes-0.5.3.tar.gz", hash = "sha256:95ce33057ba4d05df50b1f3cfefab22e351868a843b3b15a46c65836283670c9", size = 692316 }-wheels = [- { url = "https://files.pythonhosted.org/packages/af/f1/720cb1409b5d0c05cff9040c0e9fba73fa4c67897d33babf905d5d46a070/ml_dtypes-0.5.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4a177b882667c69422402df6ed5c3428ce07ac2c1f844d8a1314944651439458", size = 667412 },- { url = "https://files.pythonhosted.org/packages/6a/d5/05861ede5d299f6599f86e6bc1291714e2116d96df003cfe23cc54bcc568/ml_dtypes-0.5.3-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9849ce7267444c0a717c80c6900997de4f36e2815ce34ac560a3edb2d9a64cd2", size = 4964606 },- { url = "https://files.pythonhosted.org/packages/db/dc/72992b68de367741bfab8df3b3fe7c29f982b7279d341aa5bf3e7ef737ea/ml_dtypes-0.5.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c3f5ae0309d9f888fd825c2e9d0241102fadaca81d888f26f845bc8c13c1e4ee", size = 4938435 },- { url = "https://files.pythonhosted.org/packages/81/1c/d27a930bca31fb07d975a2d7eaf3404f9388114463b9f15032813c98f893/ml_dtypes-0.5.3-cp311-cp311-win_amd64.whl", hash = "sha256:58e39349d820b5702bb6f94ea0cb2dc8ec62ee81c0267d9622067d8333596a46", size = 206334 },- { url = "https://files.pythonhosted.org/packages/1a/d8/6922499effa616012cb8dc445280f66d100a7ff39b35c864cfca019b3f89/ml_dtypes-0.5.3-cp311-cp311-win_arm64.whl", hash = "sha256:66c2756ae6cfd7f5224e355c893cfd617fa2f747b8bbd8996152cbdebad9a184", size = 157584 },- { url = "https://files.pythonhosted.org/packages/0d/eb/bc07c88a6ab002b4635e44585d80fa0b350603f11a2097c9d1bfacc03357/ml_dtypes-0.5.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:156418abeeda48ea4797db6776db3c5bdab9ac7be197c1233771e0880c304057", size = 663864 },- { url = "https://files.pythonhosted.org/packages/cf/89/11af9b0f21b99e6386b6581ab40fb38d03225f9de5f55cf52097047e2826/ml_dtypes-0.5.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1db60c154989af253f6c4a34e8a540c2c9dce4d770784d426945e09908fbb177", size = 4951313 },- { url = "https://files.pythonhosted.org/packages/d8/a9/b98b86426c24900b0c754aad006dce2863df7ce0bb2bcc2c02f9cc7e8489/ml_dtypes-0.5.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1b255acada256d1fa8c35ed07b5f6d18bc21d1556f842fbc2d5718aea2cd9e55", size = 4928805 },- { url = "https://files.pythonhosted.org/packages/50/c1/85e6be4fc09c6175f36fb05a45917837f30af9a5146a5151cb3a3f0f9e09/ml_dtypes-0.5.3-cp312-cp312-win_amd64.whl", hash = "sha256:da65e5fd3eea434ccb8984c3624bc234ddcc0d9f4c81864af611aaebcc08a50e", size = 208182 },- { url = "https://files.pythonhosted.org/packages/9e/17/cf5326d6867be057f232d0610de1458f70a8ce7b6290e4b4a277ea62b4cd/ml_dtypes-0.5.3-cp312-cp312-win_arm64.whl", hash = "sha256:8bb9cd1ce63096567f5f42851f5843b5a0ea11511e50039a7649619abfb4ba6d", size = 161560 },- { url = "https://files.pythonhosted.org/packages/2d/87/1bcc98a66de7b2455dfb292f271452cac9edc4e870796e0d87033524d790/ml_dtypes-0.5.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5103856a225465371fe119f2fef737402b705b810bd95ad5f348e6e1a6ae21af", size = 663781 },- { url = "https://files.pythonhosted.org/packages/fd/2c/bd2a79ba7c759ee192b5601b675b180a3fd6ccf48ffa27fe1782d280f1a7/ml_dtypes-0.5.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4cae435a68861660af81fa3c5af16b70ca11a17275c5b662d9c6f58294e0f113", size = 4956217 },- { url = "https://files.pythonhosted.org/packages/14/f3/091ba84e5395d7fe5b30c081a44dec881cd84b408db1763ee50768b2ab63/ml_dtypes-0.5.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6936283b56d74fbec431ca57ce58a90a908fdbd14d4e2d22eea6d72bb208a7b7", size = 4933109 },- { url = "https://files.pythonhosted.org/packages/bc/24/054036dbe32c43295382c90a1363241684c4d6aaa1ecc3df26bd0c8d5053/ml_dtypes-0.5.3-cp313-cp313-win_amd64.whl", hash = "sha256:d0f730a17cf4f343b2c7ad50cee3bd19e969e793d2be6ed911f43086460096e4", size = 208187 },- { url = "https://files.pythonhosted.org/packages/a6/3d/7dc3ec6794a4a9004c765e0c341e32355840b698f73fd2daff46f128afc1/ml_dtypes-0.5.3-cp313-cp313-win_arm64.whl", hash = "sha256:2db74788fc01914a3c7f7da0763427280adfc9cd377e9604b6b64eb8097284bd", size = 161559 },- { url = "https://files.pythonhosted.org/packages/12/91/e6c7a0d67a152b9330445f9f0cf8ae6eee9b83f990b8c57fe74631e42a90/ml_dtypes-0.5.3-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:93c36a08a6d158db44f2eb9ce3258e53f24a9a4a695325a689494f0fdbc71770", size = 689321 },- { url = "https://files.pythonhosted.org/packages/9e/6c/b7b94b84a104a5be1883305b87d4c6bd6ae781504474b4cca067cb2340ec/ml_dtypes-0.5.3-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0e44a3761f64bc009d71ddb6d6c71008ba21b53ab6ee588dadab65e2fa79eafc", size = 5274495 },- { url = "https://files.pythonhosted.org/packages/5b/38/6266604dffb43378055394ea110570cf261a49876fc48f548dfe876f34cc/ml_dtypes-0.5.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bdf40d2aaabd3913dec11840f0d0ebb1b93134f99af6a0a4fd88ffe924928ab4", size = 5285422 },- { url = "https://files.pythonhosted.org/packages/7c/88/8612ff177d043a474b9408f0382605d881eeb4125ba89d4d4b3286573a83/ml_dtypes-0.5.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:aec640bd94c4c85c0d11e2733bd13cbb10438fb004852996ec0efbc6cacdaf70", size = 661182 },- { url = "https://files.pythonhosted.org/packages/6f/2b/0569a5e88b29240d373e835107c94ae9256fb2191d3156b43b2601859eff/ml_dtypes-0.5.3-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bda32ce212baa724e03c68771e5c69f39e584ea426bfe1a701cb01508ffc7035", size = 4956187 },- { url = "https://files.pythonhosted.org/packages/51/66/273c2a06ae44562b104b61e6b14444da00061fd87652506579d7eb2c40b1/ml_dtypes-0.5.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c205cac07d24a29840c163d6469f61069ce4b065518519216297fc2f261f8db9", size = 4930911 },- { url = "https://files.pythonhosted.org/packages/93/ab/606be3e87dc0821bd360c8c1ee46108025c31a4f96942b63907bb441b87d/ml_dtypes-0.5.3-cp314-cp314-win_amd64.whl", hash = "sha256:cd7c0bb22d4ff86d65ad61b5dd246812e8993fbc95b558553624c33e8b6903ea", size = 216664 },- { url = "https://files.pythonhosted.org/packages/30/a2/e900690ca47d01dffffd66375c5de8c4f8ced0f1ef809ccd3b25b3e6b8fa/ml_dtypes-0.5.3-cp314-cp314-win_arm64.whl", hash = "sha256:9d55ea7f7baf2aed61bf1872116cefc9d0c3693b45cae3916897ee27ef4b835e", size = 160203 },- { url = "https://files.pythonhosted.org/packages/53/21/783dfb51f40d2660afeb9bccf3612b99f6a803d980d2a09132b0f9d216ab/ml_dtypes-0.5.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:e12e29764a0e66a7a31e9b8bf1de5cc0423ea72979f45909acd4292de834ccd3", size = 689324 },- { url = "https://files.pythonhosted.org/packages/09/f7/a82d249c711abf411ac027b7163f285487f5e615c3e0716c61033ce996ab/ml_dtypes-0.5.3-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:19f6c3a4f635c2fc9e2aa7d91416bd7a3d649b48350c51f7f715a09370a90d93", size = 5275917 },- { url = "https://files.pythonhosted.org/packages/7f/3c/541c4b30815ab90ebfbb51df15d0b4254f2f9f1e2b4907ab229300d5e6f2/ml_dtypes-0.5.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ab039ffb40f3dc0aeeeba84fd6c3452781b5e15bef72e2d10bcb33e4bbffc39", size = 5285284 },-]+sdist = { url = "https://files.pythonhosted.org/packages/bf/f2/26729cc4e2a893dcabdab4f171e43b2d082756fde1af7cde31f616fc3a31/nuitka-4.0.1.tar.gz", hash = "sha256:8a8dedd549049a145e1545206a082bfbe0bc610457a71d837e560e7cf015635c", size = 4417011, upload-time = "2026-02-14T20:51:34.903Z" }[[package]]name = "numba"-version = "0.62.1"+version = "0.63.1"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "llvmlite" },{ name = "numpy" },]-sdist = { url = "https://files.pythonhosted.org/packages/a3/20/33dbdbfe60e5fd8e3dbfde299d106279a33d9f8308346022316781368591/numba-0.62.1.tar.gz", hash = "sha256:7b774242aa890e34c21200a1fc62e5b5757d5286267e71103257f4e2af0d5161", size = 2749817 }+sdist = { url = "https://files.pythonhosted.org/packages/dc/60/0145d479b2209bd8fdae5f44201eceb8ce5a23e0ed54c71f57db24618665/numba-0.63.1.tar.gz", hash = "sha256:b320aa675d0e3b17b40364935ea52a7b1c670c9037c39cf92c49502a75902f4b", size = 2761666, upload-time = "2025-12-10T02:57:39.002Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/dd/5f/8b3491dd849474f55e33c16ef55678ace1455c490555337899c35826836c/numba-0.62.1-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:f43e24b057714e480fe44bc6031de499e7cf8150c63eb461192caa6cc8530bc8", size = 2684279 },- { url = "https://files.pythonhosted.org/packages/bf/18/71969149bfeb65a629e652b752b80167fe8a6a6f6e084f1f2060801f7f31/numba-0.62.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:57cbddc53b9ee02830b828a8428757f5c218831ccc96490a314ef569d8342b7b", size = 2687330 },- { url = "https://files.pythonhosted.org/packages/0e/7d/403be3fecae33088027bc8a95dc80a2fda1e3beff3e0e5fc4374ada3afbe/numba-0.62.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:604059730c637c7885386521bb1b0ddcbc91fd56131a6dcc54163d6f1804c872", size = 3739727 },- { url = "https://files.pythonhosted.org/packages/e0/c3/3d910d08b659a6d4c62ab3cd8cd93c4d8b7709f55afa0d79a87413027ff6/numba-0.62.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d6c540880170bee817011757dc9049dba5a29db0c09b4d2349295991fe3ee55f", size = 3445490 },- { url = "https://files.pythonhosted.org/packages/5b/82/9d425c2f20d9f0a37f7cb955945a553a00fa06a2b025856c3550227c5543/numba-0.62.1-cp311-cp311-win_amd64.whl", hash = "sha256:03de6d691d6b6e2b76660ba0f38f37b81ece8b2cc524a62f2a0cfae2bfb6f9da", size = 2745550 },- { url = "https://files.pythonhosted.org/packages/5e/fa/30fa6873e9f821c0ae755915a3ca444e6ff8d6a7b6860b669a3d33377ac7/numba-0.62.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:1b743b32f8fa5fff22e19c2e906db2f0a340782caf024477b97801b918cf0494", size = 2685346 },- { url = "https://files.pythonhosted.org/packages/a9/d5/504ce8dc46e0dba2790c77e6b878ee65b60fe3e7d6d0006483ef6fde5a97/numba-0.62.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:90fa21b0142bcf08ad8e32a97d25d0b84b1e921bc9423f8dda07d3652860eef6", size = 2688139 },- { url = "https://files.pythonhosted.org/packages/50/5f/6a802741176c93f2ebe97ad90751894c7b0c922b52ba99a4395e79492205/numba-0.62.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6ef84d0ac19f1bf80431347b6f4ce3c39b7ec13f48f233a48c01e2ec06ecbc59", size = 3796453 },- { url = "https://files.pythonhosted.org/packages/7e/df/efd21527d25150c4544eccc9d0b7260a5dec4b7e98b5a581990e05a133c0/numba-0.62.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9315cc5e441300e0ca07c828a627d92a6802bcbf27c5487f31ae73783c58da53", size = 3496451 },- { url = "https://files.pythonhosted.org/packages/80/44/79bfdab12a02796bf4f1841630355c82b5a69933b1d50eb15c7fa37dabe8/numba-0.62.1-cp312-cp312-win_amd64.whl", hash = "sha256:44e3aa6228039992f058f5ebfcfd372c83798e9464297bdad8cc79febcf7891e", size = 2745552 },- { url = "https://files.pythonhosted.org/packages/22/76/501ea2c07c089ef1386868f33dff2978f43f51b854e34397b20fc55e0a58/numba-0.62.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:b72489ba8411cc9fdcaa2458d8f7677751e94f0109eeb53e5becfdc818c64afb", size = 2685766 },- { url = "https://files.pythonhosted.org/packages/80/68/444986ed95350c0611d5c7b46828411c222ce41a0c76707c36425d27ce29/numba-0.62.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:44a1412095534a26fb5da2717bc755b57da5f3053965128fe3dc286652cc6a92", size = 2688741 },- { url = "https://files.pythonhosted.org/packages/78/7e/bf2e3634993d57f95305c7cee4c9c6cb3c9c78404ee7b49569a0dfecfe33/numba-0.62.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8c9460b9e936c5bd2f0570e20a0a5909ee6e8b694fd958b210e3bde3a6dba2d7", size = 3804576 },- { url = "https://files.pythonhosted.org/packages/e8/b6/8a1723fff71f63bbb1354bdc60a1513a068acc0f5322f58da6f022d20247/numba-0.62.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:728f91a874192df22d74e3fd42c12900b7ce7190b1aad3574c6c61b08313e4c5", size = 3503367 },- { url = "https://files.pythonhosted.org/packages/9c/ec/9d414e7a80d6d1dc4af0e07c6bfe293ce0b04ea4d0ed6c45dad9bd6e72eb/numba-0.62.1-cp313-cp313-win_amd64.whl", hash = "sha256:bbf3f88b461514287df66bc8d0307e949b09f2b6f67da92265094e8fa1282dd8", size = 2745529 },+ { url = "https://files.pythonhosted.org/packages/70/90/5f8614c165d2e256fbc6c57028519db6f32e4982475a372bbe550ea0454c/numba-0.63.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b33db00f18ccc790ee9911ce03fcdfe9d5124637d1ecc266f5ae0df06e02fec3", size = 2680501, upload-time = "2025-12-10T02:57:09.797Z" },+ { url = "https://files.pythonhosted.org/packages/dc/9d/d0afc4cf915edd8eadd9b2ab5b696242886ee4f97720d9322650d66a88c6/numba-0.63.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7d31ea186a78a7c0f6b1b2a3fe68057fdb291b045c52d86232b5383b6cf4fc25", size = 3744945, upload-time = "2025-12-10T02:57:11.697Z" },+ { url = "https://files.pythonhosted.org/packages/05/a9/d82f38f2ab73f3be6f838a826b545b80339762ee8969c16a8bf1d39395a8/numba-0.63.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ed3bb2fbdb651d6aac394388130a7001aab6f4541837123a4b4ab8b02716530c", size = 3450827, upload-time = "2025-12-10T02:57:13.709Z" },+ { url = "https://files.pythonhosted.org/packages/18/3f/a9b106e93c5bd7434e65f044bae0d204e20aa7f7f85d72ceb872c7c04216/numba-0.63.1-cp311-cp311-win_amd64.whl", hash = "sha256:1ecbff7688f044b1601be70113e2fb1835367ee0b28ffa8f3adf3a05418c5c87", size = 2747262, upload-time = "2025-12-10T02:57:15.664Z" },+ { url = "https://files.pythonhosted.org/packages/14/9c/c0974cd3d00ff70d30e8ff90522ba5fbb2bcee168a867d2321d8d0457676/numba-0.63.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2819cd52afa5d8d04e057bdfd54367575105f8829350d8fb5e4066fb7591cc71", size = 2680981, upload-time = "2025-12-10T02:57:17.579Z" },+ { url = "https://files.pythonhosted.org/packages/cb/70/ea2bc45205f206b7a24ee68a159f5097c9ca7e6466806e7c213587e0c2b1/numba-0.63.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5cfd45dbd3d409e713b1ccfdc2ee72ca82006860254429f4ef01867fdba5845f", size = 3801656, upload-time = "2025-12-10T02:57:19.106Z" },+ { url = "https://files.pythonhosted.org/packages/0d/82/4f4ba4fd0f99825cbf3cdefd682ca3678be1702b63362011de6e5f71f831/numba-0.63.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69a599df6976c03b7ecf15d05302696f79f7e6d10d620367407517943355bcb0", size = 3501857, upload-time = "2025-12-10T02:57:20.721Z" },+ { url = "https://files.pythonhosted.org/packages/af/fd/6540456efa90b5f6604a86ff50dabefb187e43557e9081adcad3be44f048/numba-0.63.1-cp312-cp312-win_amd64.whl", hash = "sha256:bbad8c63e4fc7eb3cdb2c2da52178e180419f7969f9a685f283b313a70b92af3", size = 2750282, upload-time = "2025-12-10T02:57:22.474Z" },+ { url = "https://files.pythonhosted.org/packages/57/f7/e19e6eff445bec52dde5bed1ebb162925a8e6f988164f1ae4b3475a73680/numba-0.63.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:0bd4fd820ef7442dcc07da184c3f54bb41d2bdb7b35bacf3448e73d081f730dc", size = 2680954, upload-time = "2025-12-10T02:57:24.145Z" },+ { url = "https://files.pythonhosted.org/packages/e9/6c/1e222edba1e20e6b113912caa9b1665b5809433cbcb042dfd133c6f1fd38/numba-0.63.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:53de693abe4be3bd4dee38e1c55f01c55ff644a6a3696a3670589e6e4c39cde2", size = 3809736, upload-time = "2025-12-10T02:57:25.836Z" },+ { url = "https://files.pythonhosted.org/packages/76/0a/590bad11a8b3feeac30a24d01198d46bdb76ad15c70d3a530691ce3cae58/numba-0.63.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:81227821a72a763c3d4ac290abbb4371d855b59fdf85d5af22a47c0e86bf8c7e", size = 3508854, upload-time = "2025-12-10T02:57:27.438Z" },+ { url = "https://files.pythonhosted.org/packages/4e/f5/3800384a24eed1e4d524669cdbc0b9b8a628800bb1e90d7bd676e5f22581/numba-0.63.1-cp313-cp313-win_amd64.whl", hash = "sha256:eb227b07c2ac37b09432a9bda5142047a2d1055646e089d4a240a2643e508102", size = 2750228, upload-time = "2025-12-10T02:57:30.36Z" },+ { url = "https://files.pythonhosted.org/packages/36/2f/53be2aa8a55ee2608ebe1231789cbb217f6ece7f5e1c685d2f0752e95a5b/numba-0.63.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:f180883e5508940cc83de8a8bea37fc6dd20fbe4e5558d4659b8b9bef5ff4731", size = 2681153, upload-time = "2025-12-10T02:57:32.016Z" },+ { url = "https://files.pythonhosted.org/packages/13/91/53e59c86759a0648282368d42ba732c29524a745fd555ed1fb1df83febbe/numba-0.63.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f0938764afa82a47c0e895637a6c55547a42c9e1d35cac42285b1fa60a8b02bb", size = 3778718, upload-time = "2025-12-10T02:57:33.764Z" },+ { url = "https://files.pythonhosted.org/packages/6c/0c/2be19eba50b0b7636f6d1f69dfb2825530537708a234ba1ff34afc640138/numba-0.63.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f90a929fa5094e062d4e0368ede1f4497d5e40f800e80aa5222c4734236a2894", size = 3478712, upload-time = "2025-12-10T02:57:35.518Z" },+ { url = "https://files.pythonhosted.org/packages/0d/5f/4d0c9e756732577a52211f31da13a3d943d185f7fb90723f56d79c696caa/numba-0.63.1-cp314-cp314-win_amd64.whl", hash = "sha256:8d6d5ce85f572ed4e1a135dbb8c0114538f9dd0e3657eeb0bb64ab204cbe2a8f", size = 2752161, upload-time = "2025-12-10T02:57:37.12Z" },][[package]]name = "numpy"version = "1.26.2"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/dd/2b/205ddff2314d4eea852e31d53b8e55eb3f32b292efc3dd86bd827ab9019d/numpy-1.26.2.tar.gz", hash = "sha256:f65738447676ab5777f11e6bbbdb8ce11b785e105f690bc45966574816b6d3ea", size = 15664248 }+sdist = { url = "https://files.pythonhosted.org/packages/dd/2b/205ddff2314d4eea852e31d53b8e55eb3f32b292efc3dd86bd827ab9019d/numpy-1.26.2.tar.gz", hash = "sha256:f65738447676ab5777f11e6bbbdb8ce11b785e105f690bc45966574816b6d3ea", size = 15664248, upload-time = "2023-11-12T23:17:31.386Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/51/3b/2ba379bf754f13041e3d8b994394e78c69cdb9d1e5dd1dba9404b24afbdf/numpy-1.26.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b96e7b9c624ef3ae2ae0e04fa9b460f6b9f17ad8b4bec6d7756510f1f6c0c841", size = 20617415 },- { url = "https://files.pythonhosted.org/packages/2e/54/218ce51bb571a70975f223671b2a86aa951e83abfd2a416a3d540f35115c/numpy-1.26.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:aa18428111fb9a591d7a9cc1b48150097ba6a7e8299fb56bdf574df650e7d1f1", size = 13987881 },- { url = "https://files.pythonhosted.org/packages/f1/97/51eb4aa087e95138477e2140b17cd795fb379b1669432413dfad68f535c1/numpy-1.26.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:06fa1ed84aa60ea6ef9f91ba57b5ed963c3729534e6e54055fc151fad0423f0a", size = 14216395 },- { url = "https://files.pythonhosted.org/packages/b6/ab/5b893944b1602a366893559bfb227fdfb3ad7c7629b2a80d039bb5924367/numpy-1.26.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:96ca5482c3dbdd051bcd1fce8034603d6ebfc125a7bd59f55b40d8f5d246832b", size = 18238922 },- { url = "https://files.pythonhosted.org/packages/81/65/abb5808f13e96145b691bfe75cd8c4b7a94a6acfc5db0e8111ea17015675/numpy-1.26.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:854ab91a2906ef29dc3925a064fcd365c7b4da743f84b123002f6139bcb3f8a7", size = 13875653 },- { url = "https://files.pythonhosted.org/packages/21/17/f9ab7b9f3b46c7d6b024d129259fd5d276aed9047e424537c48ca2e43339/numpy-1.26.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f43740ab089277d403aa07567be138fc2a89d4d9892d113b76153e0e412409f8", size = 18079981 },- { url = "https://files.pythonhosted.org/packages/ac/6b/ea1405e449059f1e2be85f55d025598c11375c8d64cdf763506b22c244ab/numpy-1.26.2-cp311-cp311-win32.whl", hash = "sha256:a2bbc29fcb1771cd7b7425f98b05307776a6baf43035d3b80c4b0f29e9545186", size = 20755674 },- { url = "https://files.pythonhosted.org/packages/da/3c/3ff05c2855eee52588f489a4e607e4a61699a0742aa03ccf641c77f9eb0a/numpy-1.26.2-cp311-cp311-win_amd64.whl", hash = "sha256:2b3fca8a5b00184828d12b073af4d0fc5fdd94b1632c2477526f6bd7842d700d", size = 15798609 },- { url = "https://files.pythonhosted.org/packages/b1/97/6694e0855b11be0fd8598d484c09edd876ec738a8741025dee072f026c33/numpy-1.26.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:a4cd6ed4a339c21f1d1b0fdf13426cb3b284555c27ac2f156dfdaaa7e16bfab0", size = 20323012 },- { url = "https://files.pythonhosted.org/packages/2a/17/1fdc154e75d24d8c20c42b71bae1b5cf752453f0fc3a2504bbb810293dd1/numpy-1.26.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5d5244aabd6ed7f312268b9247be47343a654ebea52a60f002dc70c769048e75", size = 13675818 },- { url = "https://files.pythonhosted.org/packages/a1/42/a2819c5b77fe6506662ffc13b767e0c216c02f75ae840219013ab822a473/numpy-1.26.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a3cdb4d9c70e6b8c0814239ead47da00934666f668426fc6e94cce869e13fd7", size = 13917117 },- { url = "https://files.pythonhosted.org/packages/04/89/3b831e2b50c9364069609d1335f46c488a149d5f2be14a08741c92a60009/numpy-1.26.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa317b2325f7aa0a9471663e6093c210cb2ae9c0ad824732b307d2c51983d5b6", size = 17938212 },- { url = "https://files.pythonhosted.org/packages/02/51/f078f1e7f658022150e7c8d5f99d505b40812840349d54667f98bb915b26/numpy-1.26.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:174a8880739c16c925799c018f3f55b8130c1f7c8e75ab0a6fa9d41cab092fd6", size = 13564269 },- { url = "https://files.pythonhosted.org/packages/8c/9f/2f5c6b5f63cf006e6190bf750ade791d1fee353bab654bbde2f83a3ab92e/numpy-1.26.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:f79b231bf5c16b1f39c7f4875e1ded36abee1591e98742b05d8a0fb55d8a3eec", size = 17774512 },- { url = "https://files.pythonhosted.org/packages/51/7d/6181c8778cdb15ba0a4959bb72dcc1854c89ca4824481f224c6faf7024e1/numpy-1.26.2-cp312-cp312-win32.whl", hash = "sha256:4a06263321dfd3598cacb252f51e521a8cb4b6df471bb12a7ee5cbab20ea9167", size = 19962368 },- { url = "https://files.pythonhosted.org/packages/28/75/3b679b41713bb60e2e8f6e2f87be72c971c9e718b1c17b8f8749240ddca8/numpy-1.26.2-cp312-cp312-win_amd64.whl", hash = "sha256:b04f5dc6b3efdaab541f7857351aac359e6ae3c126e2edb376929bd3b7f92d7e", size = 15504951 },+ { url = "https://files.pythonhosted.org/packages/51/3b/2ba379bf754f13041e3d8b994394e78c69cdb9d1e5dd1dba9404b24afbdf/numpy-1.26.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b96e7b9c624ef3ae2ae0e04fa9b460f6b9f17ad8b4bec6d7756510f1f6c0c841", size = 20617415, upload-time = "2023-11-12T22:57:29.251Z" },+ { url = "https://files.pythonhosted.org/packages/2e/54/218ce51bb571a70975f223671b2a86aa951e83abfd2a416a3d540f35115c/numpy-1.26.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:aa18428111fb9a591d7a9cc1b48150097ba6a7e8299fb56bdf574df650e7d1f1", size = 13987881, upload-time = "2023-11-12T22:57:58.522Z" },+ { url = "https://files.pythonhosted.org/packages/f1/97/51eb4aa087e95138477e2140b17cd795fb379b1669432413dfad68f535c1/numpy-1.26.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:06fa1ed84aa60ea6ef9f91ba57b5ed963c3729534e6e54055fc151fad0423f0a", size = 14216395, upload-time = "2023-11-12T22:58:26.86Z" },+ { url = "https://files.pythonhosted.org/packages/b6/ab/5b893944b1602a366893559bfb227fdfb3ad7c7629b2a80d039bb5924367/numpy-1.26.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:96ca5482c3dbdd051bcd1fce8034603d6ebfc125a7bd59f55b40d8f5d246832b", size = 18238922, upload-time = "2023-11-12T22:59:13.134Z" },+ { url = "https://files.pythonhosted.org/packages/81/65/abb5808f13e96145b691bfe75cd8c4b7a94a6acfc5db0e8111ea17015675/numpy-1.26.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:854ab91a2906ef29dc3925a064fcd365c7b4da743f84b123002f6139bcb3f8a7", size = 13875653, upload-time = "2023-11-12T22:59:43.412Z" },+ { url = "https://files.pythonhosted.org/packages/21/17/f9ab7b9f3b46c7d6b024d129259fd5d276aed9047e424537c48ca2e43339/numpy-1.26.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f43740ab089277d403aa07567be138fc2a89d4d9892d113b76153e0e412409f8", size = 18079981, upload-time = "2023-11-12T23:00:18.926Z" },+ { url = "https://files.pythonhosted.org/packages/ac/6b/ea1405e449059f1e2be85f55d025598c11375c8d64cdf763506b22c244ab/numpy-1.26.2-cp311-cp311-win32.whl", hash = "sha256:a2bbc29fcb1771cd7b7425f98b05307776a6baf43035d3b80c4b0f29e9545186", size = 20755674, upload-time = "2023-11-12T23:01:17.569Z" },+ { url = "https://files.pythonhosted.org/packages/da/3c/3ff05c2855eee52588f489a4e607e4a61699a0742aa03ccf641c77f9eb0a/numpy-1.26.2-cp311-cp311-win_amd64.whl", hash = "sha256:2b3fca8a5b00184828d12b073af4d0fc5fdd94b1632c2477526f6bd7842d700d", size = 15798609, upload-time = "2023-11-12T23:01:58.827Z" },+ { url = "https://files.pythonhosted.org/packages/b1/97/6694e0855b11be0fd8598d484c09edd876ec738a8741025dee072f026c33/numpy-1.26.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:a4cd6ed4a339c21f1d1b0fdf13426cb3b284555c27ac2f156dfdaaa7e16bfab0", size = 20323012, upload-time = "2023-11-12T23:02:57.091Z" },+ { url = "https://files.pythonhosted.org/packages/2a/17/1fdc154e75d24d8c20c42b71bae1b5cf752453f0fc3a2504bbb810293dd1/numpy-1.26.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5d5244aabd6ed7f312268b9247be47343a654ebea52a60f002dc70c769048e75", size = 13675818, upload-time = "2023-11-12T23:03:32.823Z" },+ { url = "https://files.pythonhosted.org/packages/a1/42/a2819c5b77fe6506662ffc13b767e0c216c02f75ae840219013ab822a473/numpy-1.26.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a3cdb4d9c70e6b8c0814239ead47da00934666f668426fc6e94cce869e13fd7", size = 13917117, upload-time = "2023-11-12T23:03:59.013Z" },+ { url = "https://files.pythonhosted.org/packages/04/89/3b831e2b50c9364069609d1335f46c488a149d5f2be14a08741c92a60009/numpy-1.26.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa317b2325f7aa0a9471663e6093c210cb2ae9c0ad824732b307d2c51983d5b6", size = 17938212, upload-time = "2023-11-12T23:04:32.896Z" },+ { url = "https://files.pythonhosted.org/packages/02/51/f078f1e7f658022150e7c8d5f99d505b40812840349d54667f98bb915b26/numpy-1.26.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:174a8880739c16c925799c018f3f55b8130c1f7c8e75ab0a6fa9d41cab092fd6", size = 13564269, upload-time = "2023-11-12T23:05:31.101Z" },+ { url = "https://files.pythonhosted.org/packages/8c/9f/2f5c6b5f63cf006e6190bf750ade791d1fee353bab654bbde2f83a3ab92e/numpy-1.26.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:f79b231bf5c16b1f39c7f4875e1ded36abee1591e98742b05d8a0fb55d8a3eec", size = 17774512, upload-time = "2023-11-12T23:06:03.941Z" },+ { url = "https://files.pythonhosted.org/packages/51/7d/6181c8778cdb15ba0a4959bb72dcc1854c89ca4824481f224c6faf7024e1/numpy-1.26.2-cp312-cp312-win32.whl", hash = "sha256:4a06263321dfd3598cacb252f51e521a8cb4b6df471bb12a7ee5cbab20ea9167", size = 19962368, upload-time = "2023-11-12T23:06:51.561Z" },+ { url = "https://files.pythonhosted.org/packages/28/75/3b679b41713bb60e2e8f6e2f87be72c971c9e718b1c17b8f8749240ddca8/numpy-1.26.2-cp312-cp312-win_amd64.whl", hash = "sha256:b04f5dc6b3efdaab541f7857351aac359e6ae3c126e2edb376929bd3b7f92d7e", size = 15504951, upload-time = "2023-11-12T23:07:33.828Z" },][[package]]@@ -1083,9 +924,9 @@ dependencies = [{ name = "numpy" },{ name = "pydantic" },]-sdist = { url = "https://files.pythonhosted.org/packages/59/ba/6bf5e0a7cc3fbfbb02a7824926cad73c58df374322eb7728b378023a76dc/numpydantic-1.7.0.tar.gz", hash = "sha256:268285bee026d9dfdf23efeee13f60c3b75d47de2ffdf2e58b4f0c17a6824e3b", size = 80412 }+sdist = { url = "https://files.pythonhosted.org/packages/59/ba/6bf5e0a7cc3fbfbb02a7824926cad73c58df374322eb7728b378023a76dc/numpydantic-1.7.0.tar.gz", hash = "sha256:268285bee026d9dfdf23efeee13f60c3b75d47de2ffdf2e58b4f0c17a6824e3b", size = 80412, upload-time = "2025-10-11T05:23:56.654Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/21/e0/42f0ea229a8b5ada24a1eae4f5522b80ab65b4083f5cea4c7372bc894af3/numpydantic-1.7.0-py3-none-any.whl", hash = "sha256:81314ed00423efa954a711a48003dba5382156e899f677f405ce043f5296b090", size = 86734 },+ { url = "https://files.pythonhosted.org/packages/21/e0/42f0ea229a8b5ada24a1eae4f5522b80ab65b4083f5cea4c7372bc894af3/numpydantic-1.7.0-py3-none-any.whl", hash = "sha256:81314ed00423efa954a711a48003dba5382156e899f677f405ce043f5296b090", size = 86734, upload-time = "2025-10-11T05:23:55.003Z" },][[package]]@@ -1095,269 +936,373 @@ source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "numpy" },]-sdist = { url = "https://files.pythonhosted.org/packages/1d/33/7b8ec6c4d45e678b26297e4a5e76464a93033a9adcc8c17eac01097065f6/opencv-contrib-python-4.10.0.84.tar.gz", hash = "sha256:4a3eae0ed9cadf1abe9293a6938a25a540e2fd6d7fc308595caa5896c8b36a0c", size = 150433857 }+sdist = { url = "https://files.pythonhosted.org/packages/1d/33/7b8ec6c4d45e678b26297e4a5e76464a93033a9adcc8c17eac01097065f6/opencv-contrib-python-4.10.0.84.tar.gz", hash = "sha256:4a3eae0ed9cadf1abe9293a6938a25a540e2fd6d7fc308595caa5896c8b36a0c", size = 150433857, upload-time = "2024-06-17T18:30:50.217Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/92/64/c1194510eaed272d86b53a08c790ca6ed1c450f06d401c49c8145fc46d40/opencv_contrib_python-4.10.0.84-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:ee4b0919026d8c533aeb69b16c6ec4a891a2f6844efaa14121bf68838753209c", size = 63667391 },- { url = "https://files.pythonhosted.org/packages/09/94/d077c4c976c2d7a88812fd55396e92edae0e0c708689dbd8c8f508920e47/opencv_contrib_python-4.10.0.84-cp37-abi3-macosx_12_0_x86_64.whl", hash = "sha256:dea80d4db73b8acccf9e16b5744bf3654f47b22745074263f0a6c10de26c5ef5", size = 66278032 },- { url = "https://files.pythonhosted.org/packages/f8/76/f76fe74b864f3cfa737173ca12e8890aad8369e980006fb8a0b6cd14c6c7/opencv_contrib_python-4.10.0.84-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:040575b69e4f3aa761676bace4e3d1b8485fbfaf77ef77b266ab6bda5a3b5e9b", size = 47384495 },- { url = "https://files.pythonhosted.org/packages/b0/e0/8f5d065ebb2e5941d289c5f653f944318f9e418bc5167bc6a346ab5e0f6a/opencv_contrib_python-4.10.0.84-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a261223db41f6e512d76deaf21c8fcfb4fbbcbc2de62ca7f74a05f2c9ee489ef", size = 68681489 },- { url = "https://files.pythonhosted.org/packages/36/30/7041bd7350cb1a26fa80415a7664b6f04f7ccbf0c12b9318d564cdf35932/opencv_contrib_python-4.10.0.84-cp37-abi3-win32.whl", hash = "sha256:2a36257ec1375d1bec2a62177ea39828ff9804de6831ee39646bdc875c343cec", size = 34506122 },- { url = "https://files.pythonhosted.org/packages/a7/9e/7110d2c5d543ab03b9581dbb1f8e2429863e44e0c9b4960b766f230c1279/opencv_contrib_python-4.10.0.84-cp37-abi3-win_amd64.whl", hash = "sha256:47ec3160dae75f70e099b286d1a2e086d20dac8b06e759f60eaf867e6bdecba7", size = 45541421 },+ { url = "https://files.pythonhosted.org/packages/92/64/c1194510eaed272d86b53a08c790ca6ed1c450f06d401c49c8145fc46d40/opencv_contrib_python-4.10.0.84-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:ee4b0919026d8c533aeb69b16c6ec4a891a2f6844efaa14121bf68838753209c", size = 63667391, upload-time = "2024-06-18T04:57:54.718Z" },+ { url = "https://files.pythonhosted.org/packages/09/94/d077c4c976c2d7a88812fd55396e92edae0e0c708689dbd8c8f508920e47/opencv_contrib_python-4.10.0.84-cp37-abi3-macosx_12_0_x86_64.whl", hash = "sha256:dea80d4db73b8acccf9e16b5744bf3654f47b22745074263f0a6c10de26c5ef5", size = 66278032, upload-time = "2024-06-17T19:34:23.718Z" },+ { url = "https://files.pythonhosted.org/packages/f8/76/f76fe74b864f3cfa737173ca12e8890aad8369e980006fb8a0b6cd14c6c7/opencv_contrib_python-4.10.0.84-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:040575b69e4f3aa761676bace4e3d1b8485fbfaf77ef77b266ab6bda5a3b5e9b", size = 47384495, upload-time = "2024-06-17T20:00:39.027Z" },+ { url = "https://files.pythonhosted.org/packages/b0/e0/8f5d065ebb2e5941d289c5f653f944318f9e418bc5167bc6a346ab5e0f6a/opencv_contrib_python-4.10.0.84-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a261223db41f6e512d76deaf21c8fcfb4fbbcbc2de62ca7f74a05f2c9ee489ef", size = 68681489, upload-time = "2024-06-17T18:30:32.918Z" },+ { url = "https://files.pythonhosted.org/packages/36/30/7041bd7350cb1a26fa80415a7664b6f04f7ccbf0c12b9318d564cdf35932/opencv_contrib_python-4.10.0.84-cp37-abi3-win32.whl", hash = "sha256:2a36257ec1375d1bec2a62177ea39828ff9804de6831ee39646bdc875c343cec", size = 34506122, upload-time = "2024-06-17T18:28:29.922Z" },+ { url = "https://files.pythonhosted.org/packages/a7/9e/7110d2c5d543ab03b9581dbb1f8e2429863e44e0c9b4960b766f230c1279/opencv_contrib_python-4.10.0.84-cp37-abi3-win_amd64.whl", hash = "sha256:47ec3160dae75f70e099b286d1a2e086d20dac8b06e759f60eaf867e6bdecba7", size = 45541421, upload-time = "2024-06-17T18:28:46.012Z" },][[package]]-name = "opt-einsum"-version = "3.4.0"+name = "packaging"+version = "26.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/8c/b9/2ac072041e899a52f20cf9510850ff58295003aa75525e58343591b0cbfb/opt_einsum-3.4.0.tar.gz", hash = "sha256:96ca72f1b886d148241348783498194c577fa30a8faac108586b14f1ba4473ac", size = 63004 }+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/23/cd/066e86230ae37ed0be70aae89aabf03ca8d9f39c8aea0dec8029455b5540/opt_einsum-3.4.0-py3-none-any.whl", hash = "sha256:69bb92469f86a1565195ece4ac0323943e83477171b91d24c35afe028a90d7cd", size = 71932 },+ { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },][[package]]-name = "packaging"-version = "25.0"+name = "pandas"+version = "2.3.3"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727 }-wheels = [- { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469 },+resolution-markers = [+ "python_full_version >= '3.14' and sys_platform == 'darwin'",+ "python_full_version >= '3.14' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "python_full_version >= '3.14' and sys_platform == 'win32'",+ "python_full_version >= '3.14' and sys_platform == 'emscripten'",+ "(python_full_version >= '3.14' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",+]+dependencies = [+ { name = "numpy", marker = "python_full_version >= '3.14'" },+ { name = "python-dateutil", marker = "python_full_version >= '3.14'" },+ { name = "pytz", marker = "python_full_version >= '3.14'" },+ { name = "tzdata", marker = "python_full_version >= '3.14'" },+]+sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/c1/fa/7ac648108144a095b4fb6aa3de1954689f7af60a14cf25583f4960ecb878/pandas-2.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:602b8615ebcc4a0c1751e71840428ddebeb142ec02c786e8ad6b1ce3c8dec523", size = 11578790, upload-time = "2025-09-29T23:18:30.065Z" },+ { url = "https://files.pythonhosted.org/packages/9b/35/74442388c6cf008882d4d4bdfc4109be87e9b8b7ccd097ad1e7f006e2e95/pandas-2.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8fe25fc7b623b0ef6b5009149627e34d2a4657e880948ec3c840e9402e5c1b45", size = 10833831, upload-time = "2025-09-29T23:38:56.071Z" },+ { url = "https://files.pythonhosted.org/packages/fe/e4/de154cbfeee13383ad58d23017da99390b91d73f8c11856f2095e813201b/pandas-2.3.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b468d3dad6ff947df92dcb32ede5b7bd41a9b3cceef0a30ed925f6d01fb8fa66", size = 12199267, upload-time = "2025-09-29T23:18:41.627Z" },+ { url = "https://files.pythonhosted.org/packages/bf/c9/63f8d545568d9ab91476b1818b4741f521646cbdd151c6efebf40d6de6f7/pandas-2.3.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b98560e98cb334799c0b07ca7967ac361a47326e9b4e5a7dfb5ab2b1c9d35a1b", size = 12789281, upload-time = "2025-09-29T23:18:56.834Z" },+ { url = "https://files.pythonhosted.org/packages/f2/00/a5ac8c7a0e67fd1a6059e40aa08fa1c52cc00709077d2300e210c3ce0322/pandas-2.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37b5848ba49824e5c30bedb9c830ab9b7751fd049bc7914533e01c65f79791", size = 13240453, upload-time = "2025-09-29T23:19:09.247Z" },+ { url = "https://files.pythonhosted.org/packages/27/4d/5c23a5bc7bd209231618dd9e606ce076272c9bc4f12023a70e03a86b4067/pandas-2.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db4301b2d1f926ae677a751eb2bd0e8c5f5319c9cb3f88b0becbbb0b07b34151", size = 13890361, upload-time = "2025-09-29T23:19:25.342Z" },+ { url = "https://files.pythonhosted.org/packages/8e/59/712db1d7040520de7a4965df15b774348980e6df45c129b8c64d0dbe74ef/pandas-2.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:f086f6fe114e19d92014a1966f43a3e62285109afe874f067f5abbdcbb10e59c", size = 11348702, upload-time = "2025-09-29T23:19:38.296Z" },+ { url = "https://files.pythonhosted.org/packages/9c/fb/231d89e8637c808b997d172b18e9d4a4bc7bf31296196c260526055d1ea0/pandas-2.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d21f6d74eb1725c2efaa71a2bfc661a0689579b58e9c0ca58a739ff0b002b53", size = 11597846, upload-time = "2025-09-29T23:19:48.856Z" },+ { url = "https://files.pythonhosted.org/packages/5c/bd/bf8064d9cfa214294356c2d6702b716d3cf3bb24be59287a6a21e24cae6b/pandas-2.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3fd2f887589c7aa868e02632612ba39acb0b8948faf5cc58f0850e165bd46f35", size = 10729618, upload-time = "2025-09-29T23:39:08.659Z" },+ { url = "https://files.pythonhosted.org/packages/57/56/cf2dbe1a3f5271370669475ead12ce77c61726ffd19a35546e31aa8edf4e/pandas-2.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecaf1e12bdc03c86ad4a7ea848d66c685cb6851d807a26aa245ca3d2017a1908", size = 11737212, upload-time = "2025-09-29T23:19:59.765Z" },+ { url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89", size = 12362693, upload-time = "2025-09-29T23:20:14.098Z" },+ { url = "https://files.pythonhosted.org/packages/a6/de/8b1895b107277d52f2b42d3a6806e69cfef0d5cf1d0ba343470b9d8e0a04/pandas-2.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a68e15f780eddf2b07d242e17a04aa187a7ee12b40b930bfdd78070556550e98", size = 12771002, upload-time = "2025-09-29T23:20:26.76Z" },+ { url = "https://files.pythonhosted.org/packages/87/21/84072af3187a677c5893b170ba2c8fbe450a6ff911234916da889b698220/pandas-2.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:371a4ab48e950033bcf52b6527eccb564f52dc826c02afd9a1bc0ab731bba084", size = 13450971, upload-time = "2025-09-29T23:20:41.344Z" },+ { url = "https://files.pythonhosted.org/packages/86/41/585a168330ff063014880a80d744219dbf1dd7a1c706e75ab3425a987384/pandas-2.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:a16dcec078a01eeef8ee61bf64074b4e524a2a3f4b3be9326420cabe59c4778b", size = 10992722, upload-time = "2025-09-29T23:20:54.139Z" },+ { url = "https://files.pythonhosted.org/packages/cd/4b/18b035ee18f97c1040d94debd8f2e737000ad70ccc8f5513f4eefad75f4b/pandas-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:56851a737e3470de7fa88e6131f41281ed440d29a9268dcbf0002da5ac366713", size = 11544671, upload-time = "2025-09-29T23:21:05.024Z" },+ { url = "https://files.pythonhosted.org/packages/31/94/72fac03573102779920099bcac1c3b05975c2cb5f01eac609faf34bed1ca/pandas-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdcd9d1167f4885211e401b3036c0c8d9e274eee67ea8d0758a256d60704cfe8", size = 10680807, upload-time = "2025-09-29T23:21:15.979Z" },+ { url = "https://files.pythonhosted.org/packages/16/87/9472cf4a487d848476865321de18cc8c920b8cab98453ab79dbbc98db63a/pandas-2.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e32e7cc9af0f1cc15548288a51a3b681cc2a219faa838e995f7dc53dbab1062d", size = 11709872, upload-time = "2025-09-29T23:21:27.165Z" },+ { url = "https://files.pythonhosted.org/packages/15/07/284f757f63f8a8d69ed4472bfd85122bd086e637bf4ed09de572d575a693/pandas-2.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318d77e0e42a628c04dc56bcef4b40de67918f7041c2b061af1da41dcff670ac", size = 12306371, upload-time = "2025-09-29T23:21:40.532Z" },+ { url = "https://files.pythonhosted.org/packages/33/81/a3afc88fca4aa925804a27d2676d22dcd2031c2ebe08aabd0ae55b9ff282/pandas-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e0a175408804d566144e170d0476b15d78458795bb18f1304fb94160cabf40c", size = 12765333, upload-time = "2025-09-29T23:21:55.77Z" },+ { url = "https://files.pythonhosted.org/packages/8d/0f/b4d4ae743a83742f1153464cf1a8ecfafc3ac59722a0b5c8602310cb7158/pandas-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2d9ab0fc11822b5eece72ec9587e172f63cff87c00b062f6e37448ced4493", size = 13418120, upload-time = "2025-09-29T23:22:10.109Z" },+ { url = "https://files.pythonhosted.org/packages/4f/c7/e54682c96a895d0c808453269e0b5928a07a127a15704fedb643e9b0a4c8/pandas-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f8bfc0e12dc78f777f323f55c58649591b2cd0c43534e8355c51d3fede5f4dee", size = 10993991, upload-time = "2025-09-29T23:25:04.889Z" },+ { url = "https://files.pythonhosted.org/packages/f9/ca/3f8d4f49740799189e1395812f3bf23b5e8fc7c190827d55a610da72ce55/pandas-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:75ea25f9529fdec2d2e93a42c523962261e567d250b0013b16210e1d40d7c2e5", size = 12048227, upload-time = "2025-09-29T23:22:24.343Z" },+ { url = "https://files.pythonhosted.org/packages/0e/5a/f43efec3e8c0cc92c4663ccad372dbdff72b60bdb56b2749f04aa1d07d7e/pandas-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:74ecdf1d301e812db96a465a525952f4dde225fdb6d8e5a521d47e1f42041e21", size = 11411056, upload-time = "2025-09-29T23:22:37.762Z" },+ { url = "https://files.pythonhosted.org/packages/46/b1/85331edfc591208c9d1a63a06baa67b21d332e63b7a591a5ba42a10bb507/pandas-2.3.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6435cb949cb34ec11cc9860246ccb2fdc9ecd742c12d3304989017d53f039a78", size = 11645189, upload-time = "2025-09-29T23:22:51.688Z" },+ { url = "https://files.pythonhosted.org/packages/44/23/78d645adc35d94d1ac4f2a3c4112ab6f5b8999f4898b8cdf01252f8df4a9/pandas-2.3.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:900f47d8f20860de523a1ac881c4c36d65efcb2eb850e6948140fa781736e110", size = 12121912, upload-time = "2025-09-29T23:23:05.042Z" },+ { url = "https://files.pythonhosted.org/packages/53/da/d10013df5e6aaef6b425aa0c32e1fc1f3e431e4bcabd420517dceadce354/pandas-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a45c765238e2ed7d7c608fc5bc4a6f88b642f2f01e70c0c23d2224dd21829d86", size = 12712160, upload-time = "2025-09-29T23:23:28.57Z" },+ { url = "https://files.pythonhosted.org/packages/bd/17/e756653095a083d8a37cbd816cb87148debcfcd920129b25f99dd8d04271/pandas-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4fc4c21971a1a9f4bdb4c73978c7f7256caa3e62b323f70d6cb80db583350bc", size = 13199233, upload-time = "2025-09-29T23:24:24.876Z" },+ { url = "https://files.pythonhosted.org/packages/04/fd/74903979833db8390b73b3a8a7d30d146d710bd32703724dd9083950386f/pandas-2.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ee15f284898e7b246df8087fc82b87b01686f98ee67d85a17b7ab44143a3a9a0", size = 11540635, upload-time = "2025-09-29T23:25:52.486Z" },+ { url = "https://files.pythonhosted.org/packages/21/00/266d6b357ad5e6d3ad55093a7e8efc7dd245f5a842b584db9f30b0f0a287/pandas-2.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1611aedd912e1ff81ff41c745822980c49ce4a7907537be8692c8dbc31924593", size = 10759079, upload-time = "2025-09-29T23:26:33.204Z" },+ { url = "https://files.pythonhosted.org/packages/ca/05/d01ef80a7a3a12b2f8bbf16daba1e17c98a2f039cbc8e2f77a2c5a63d382/pandas-2.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d2cefc361461662ac48810cb14365a365ce864afe85ef1f447ff5a1e99ea81c", size = 11814049, upload-time = "2025-09-29T23:27:15.384Z" },+ { url = "https://files.pythonhosted.org/packages/15/b2/0e62f78c0c5ba7e3d2c5945a82456f4fac76c480940f805e0b97fcbc2f65/pandas-2.3.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ee67acbbf05014ea6c763beb097e03cd629961c8a632075eeb34247120abcb4b", size = 12332638, upload-time = "2025-09-29T23:27:51.625Z" },+ { url = "https://files.pythonhosted.org/packages/c5/33/dd70400631b62b9b29c3c93d2feee1d0964dc2bae2e5ad7a6c73a7f25325/pandas-2.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c46467899aaa4da076d5abc11084634e2d197e9460643dd455ac3db5856b24d6", size = 12886834, upload-time = "2025-09-29T23:28:21.289Z" },+ { url = "https://files.pythonhosted.org/packages/d3/18/b5d48f55821228d0d2692b34fd5034bb185e854bdb592e9c640f6290e012/pandas-2.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6253c72c6a1d990a410bc7de641d34053364ef8bcd3126f7e7450125887dffe3", size = 13409925, upload-time = "2025-09-29T23:28:58.261Z" },+ { url = "https://files.pythonhosted.org/packages/a6/3d/124ac75fcd0ecc09b8fdccb0246ef65e35b012030defb0e0eba2cbbbe948/pandas-2.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:1b07204a219b3b7350abaae088f451860223a52cfb8a6c53358e7948735158e5", size = 11109071, upload-time = "2025-09-29T23:32:27.484Z" },+ { url = "https://files.pythonhosted.org/packages/89/9c/0e21c895c38a157e0faa1fb64587a9226d6dd46452cac4532d80c3c4a244/pandas-2.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2462b1a365b6109d275250baaae7b760fd25c726aaca0054649286bcfbb3e8ec", size = 12048504, upload-time = "2025-09-29T23:29:31.47Z" },+ { url = "https://files.pythonhosted.org/packages/d7/82/b69a1c95df796858777b68fbe6a81d37443a33319761d7c652ce77797475/pandas-2.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0242fe9a49aa8b4d78a4fa03acb397a58833ef6199e9aa40a95f027bb3a1b6e7", size = 11410702, upload-time = "2025-09-29T23:29:54.591Z" },+ { url = "https://files.pythonhosted.org/packages/f9/88/702bde3ba0a94b8c73a0181e05144b10f13f29ebfc2150c3a79062a8195d/pandas-2.3.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a21d830e78df0a515db2b3d2f5570610f5e6bd2e27749770e8bb7b524b89b450", size = 11634535, upload-time = "2025-09-29T23:30:21.003Z" },+ { url = "https://files.pythonhosted.org/packages/a4/1e/1bac1a839d12e6a82ec6cb40cda2edde64a2013a66963293696bbf31fbbb/pandas-2.3.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2e3ebdb170b5ef78f19bfb71b0dc5dc58775032361fa188e814959b74d726dd5", size = 12121582, upload-time = "2025-09-29T23:30:43.391Z" },+ { url = "https://files.pythonhosted.org/packages/44/91/483de934193e12a3b1d6ae7c8645d083ff88dec75f46e827562f1e4b4da6/pandas-2.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d051c0e065b94b7a3cea50eb1ec32e912cd96dba41647eb24104b6c6c14c5788", size = 12699963, upload-time = "2025-09-29T23:31:10.009Z" },+ { url = "https://files.pythonhosted.org/packages/70/44/5191d2e4026f86a2a109053e194d3ba7a31a2d10a9c2348368c63ed4e85a/pandas-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3869faf4bd07b3b66a9f462417d0ca3a9df29a9f6abd5d0d0dbab15dac7abe87", size = 13202175, upload-time = "2025-09-29T23:31:59.173Z" },][[package]]name = "pandas"-version = "2.3.3"+version = "3.0.1"source = { registry = "https://pypi.org/simple" }+resolution-markers = [+ "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'darwin'",+ "python_full_version >= '3.12' and python_full_version < '3.14' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'win32'",+ "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform == 'emscripten'",+ "(python_full_version >= '3.12' and python_full_version < '3.14' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",+ "python_full_version < '3.12' and sys_platform == 'darwin'",+ "python_full_version < '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "python_full_version < '3.12' and sys_platform == 'win32'",+ "python_full_version < '3.12' and sys_platform == 'emscripten'",+ "(python_full_version < '3.12' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.12' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",+]dependencies = [- { name = "numpy" },- { name = "python-dateutil" },- { name = "pytz" },- { name = "tzdata" },-]-sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223 }-wheels = [- { url = "https://files.pythonhosted.org/packages/c1/fa/7ac648108144a095b4fb6aa3de1954689f7af60a14cf25583f4960ecb878/pandas-2.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:602b8615ebcc4a0c1751e71840428ddebeb142ec02c786e8ad6b1ce3c8dec523", size = 11578790 },- { url = "https://files.pythonhosted.org/packages/9b/35/74442388c6cf008882d4d4bdfc4109be87e9b8b7ccd097ad1e7f006e2e95/pandas-2.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8fe25fc7b623b0ef6b5009149627e34d2a4657e880948ec3c840e9402e5c1b45", size = 10833831 },- { url = "https://files.pythonhosted.org/packages/fe/e4/de154cbfeee13383ad58d23017da99390b91d73f8c11856f2095e813201b/pandas-2.3.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b468d3dad6ff947df92dcb32ede5b7bd41a9b3cceef0a30ed925f6d01fb8fa66", size = 12199267 },- { url = "https://files.pythonhosted.org/packages/bf/c9/63f8d545568d9ab91476b1818b4741f521646cbdd151c6efebf40d6de6f7/pandas-2.3.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b98560e98cb334799c0b07ca7967ac361a47326e9b4e5a7dfb5ab2b1c9d35a1b", size = 12789281 },- { url = "https://files.pythonhosted.org/packages/f2/00/a5ac8c7a0e67fd1a6059e40aa08fa1c52cc00709077d2300e210c3ce0322/pandas-2.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37b5848ba49824e5c30bedb9c830ab9b7751fd049bc7914533e01c65f79791", size = 13240453 },- { url = "https://files.pythonhosted.org/packages/27/4d/5c23a5bc7bd209231618dd9e606ce076272c9bc4f12023a70e03a86b4067/pandas-2.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db4301b2d1f926ae677a751eb2bd0e8c5f5319c9cb3f88b0becbbb0b07b34151", size = 13890361 },- { url = "https://files.pythonhosted.org/packages/8e/59/712db1d7040520de7a4965df15b774348980e6df45c129b8c64d0dbe74ef/pandas-2.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:f086f6fe114e19d92014a1966f43a3e62285109afe874f067f5abbdcbb10e59c", size = 11348702 },- { url = "https://files.pythonhosted.org/packages/9c/fb/231d89e8637c808b997d172b18e9d4a4bc7bf31296196c260526055d1ea0/pandas-2.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d21f6d74eb1725c2efaa71a2bfc661a0689579b58e9c0ca58a739ff0b002b53", size = 11597846 },- { url = "https://files.pythonhosted.org/packages/5c/bd/bf8064d9cfa214294356c2d6702b716d3cf3bb24be59287a6a21e24cae6b/pandas-2.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3fd2f887589c7aa868e02632612ba39acb0b8948faf5cc58f0850e165bd46f35", size = 10729618 },- { url = "https://files.pythonhosted.org/packages/57/56/cf2dbe1a3f5271370669475ead12ce77c61726ffd19a35546e31aa8edf4e/pandas-2.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecaf1e12bdc03c86ad4a7ea848d66c685cb6851d807a26aa245ca3d2017a1908", size = 11737212 },- { url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89", size = 12362693 },- { url = "https://files.pythonhosted.org/packages/a6/de/8b1895b107277d52f2b42d3a6806e69cfef0d5cf1d0ba343470b9d8e0a04/pandas-2.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a68e15f780eddf2b07d242e17a04aa187a7ee12b40b930bfdd78070556550e98", size = 12771002 },- { url = "https://files.pythonhosted.org/packages/87/21/84072af3187a677c5893b170ba2c8fbe450a6ff911234916da889b698220/pandas-2.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:371a4ab48e950033bcf52b6527eccb564f52dc826c02afd9a1bc0ab731bba084", size = 13450971 },- { url = "https://files.pythonhosted.org/packages/86/41/585a168330ff063014880a80d744219dbf1dd7a1c706e75ab3425a987384/pandas-2.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:a16dcec078a01eeef8ee61bf64074b4e524a2a3f4b3be9326420cabe59c4778b", size = 10992722 },- { url = "https://files.pythonhosted.org/packages/cd/4b/18b035ee18f97c1040d94debd8f2e737000ad70ccc8f5513f4eefad75f4b/pandas-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:56851a737e3470de7fa88e6131f41281ed440d29a9268dcbf0002da5ac366713", size = 11544671 },- { url = "https://files.pythonhosted.org/packages/31/94/72fac03573102779920099bcac1c3b05975c2cb5f01eac609faf34bed1ca/pandas-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdcd9d1167f4885211e401b3036c0c8d9e274eee67ea8d0758a256d60704cfe8", size = 10680807 },- { url = "https://files.pythonhosted.org/packages/16/87/9472cf4a487d848476865321de18cc8c920b8cab98453ab79dbbc98db63a/pandas-2.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e32e7cc9af0f1cc15548288a51a3b681cc2a219faa838e995f7dc53dbab1062d", size = 11709872 },- { url = "https://files.pythonhosted.org/packages/15/07/284f757f63f8a8d69ed4472bfd85122bd086e637bf4ed09de572d575a693/pandas-2.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318d77e0e42a628c04dc56bcef4b40de67918f7041c2b061af1da41dcff670ac", size = 12306371 },- { url = "https://files.pythonhosted.org/packages/33/81/a3afc88fca4aa925804a27d2676d22dcd2031c2ebe08aabd0ae55b9ff282/pandas-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e0a175408804d566144e170d0476b15d78458795bb18f1304fb94160cabf40c", size = 12765333 },- { url = "https://files.pythonhosted.org/packages/8d/0f/b4d4ae743a83742f1153464cf1a8ecfafc3ac59722a0b5c8602310cb7158/pandas-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2d9ab0fc11822b5eece72ec9587e172f63cff87c00b062f6e37448ced4493", size = 13418120 },- { url = "https://files.pythonhosted.org/packages/4f/c7/e54682c96a895d0c808453269e0b5928a07a127a15704fedb643e9b0a4c8/pandas-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f8bfc0e12dc78f777f323f55c58649591b2cd0c43534e8355c51d3fede5f4dee", size = 10993991 },- { url = "https://files.pythonhosted.org/packages/f9/ca/3f8d4f49740799189e1395812f3bf23b5e8fc7c190827d55a610da72ce55/pandas-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:75ea25f9529fdec2d2e93a42c523962261e567d250b0013b16210e1d40d7c2e5", size = 12048227 },- { url = "https://files.pythonhosted.org/packages/0e/5a/f43efec3e8c0cc92c4663ccad372dbdff72b60bdb56b2749f04aa1d07d7e/pandas-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:74ecdf1d301e812db96a465a525952f4dde225fdb6d8e5a521d47e1f42041e21", size = 11411056 },- { url = "https://files.pythonhosted.org/packages/46/b1/85331edfc591208c9d1a63a06baa67b21d332e63b7a591a5ba42a10bb507/pandas-2.3.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6435cb949cb34ec11cc9860246ccb2fdc9ecd742c12d3304989017d53f039a78", size = 11645189 },- { url = "https://files.pythonhosted.org/packages/44/23/78d645adc35d94d1ac4f2a3c4112ab6f5b8999f4898b8cdf01252f8df4a9/pandas-2.3.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:900f47d8f20860de523a1ac881c4c36d65efcb2eb850e6948140fa781736e110", size = 12121912 },- { url = "https://files.pythonhosted.org/packages/53/da/d10013df5e6aaef6b425aa0c32e1fc1f3e431e4bcabd420517dceadce354/pandas-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a45c765238e2ed7d7c608fc5bc4a6f88b642f2f01e70c0c23d2224dd21829d86", size = 12712160 },- { url = "https://files.pythonhosted.org/packages/bd/17/e756653095a083d8a37cbd816cb87148debcfcd920129b25f99dd8d04271/pandas-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4fc4c21971a1a9f4bdb4c73978c7f7256caa3e62b323f70d6cb80db583350bc", size = 13199233 },- { url = "https://files.pythonhosted.org/packages/04/fd/74903979833db8390b73b3a8a7d30d146d710bd32703724dd9083950386f/pandas-2.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ee15f284898e7b246df8087fc82b87b01686f98ee67d85a17b7ab44143a3a9a0", size = 11540635 },- { url = "https://files.pythonhosted.org/packages/21/00/266d6b357ad5e6d3ad55093a7e8efc7dd245f5a842b584db9f30b0f0a287/pandas-2.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1611aedd912e1ff81ff41c745822980c49ce4a7907537be8692c8dbc31924593", size = 10759079 },- { url = "https://files.pythonhosted.org/packages/ca/05/d01ef80a7a3a12b2f8bbf16daba1e17c98a2f039cbc8e2f77a2c5a63d382/pandas-2.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d2cefc361461662ac48810cb14365a365ce864afe85ef1f447ff5a1e99ea81c", size = 11814049 },- { url = "https://files.pythonhosted.org/packages/15/b2/0e62f78c0c5ba7e3d2c5945a82456f4fac76c480940f805e0b97fcbc2f65/pandas-2.3.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ee67acbbf05014ea6c763beb097e03cd629961c8a632075eeb34247120abcb4b", size = 12332638 },- { url = "https://files.pythonhosted.org/packages/c5/33/dd70400631b62b9b29c3c93d2feee1d0964dc2bae2e5ad7a6c73a7f25325/pandas-2.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c46467899aaa4da076d5abc11084634e2d197e9460643dd455ac3db5856b24d6", size = 12886834 },- { url = "https://files.pythonhosted.org/packages/d3/18/b5d48f55821228d0d2692b34fd5034bb185e854bdb592e9c640f6290e012/pandas-2.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6253c72c6a1d990a410bc7de641d34053364ef8bcd3126f7e7450125887dffe3", size = 13409925 },- { url = "https://files.pythonhosted.org/packages/a6/3d/124ac75fcd0ecc09b8fdccb0246ef65e35b012030defb0e0eba2cbbbe948/pandas-2.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:1b07204a219b3b7350abaae088f451860223a52cfb8a6c53358e7948735158e5", size = 11109071 },- { url = "https://files.pythonhosted.org/packages/89/9c/0e21c895c38a157e0faa1fb64587a9226d6dd46452cac4532d80c3c4a244/pandas-2.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2462b1a365b6109d275250baaae7b760fd25c726aaca0054649286bcfbb3e8ec", size = 12048504 },- { url = "https://files.pythonhosted.org/packages/d7/82/b69a1c95df796858777b68fbe6a81d37443a33319761d7c652ce77797475/pandas-2.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0242fe9a49aa8b4d78a4fa03acb397a58833ef6199e9aa40a95f027bb3a1b6e7", size = 11410702 },- { url = "https://files.pythonhosted.org/packages/f9/88/702bde3ba0a94b8c73a0181e05144b10f13f29ebfc2150c3a79062a8195d/pandas-2.3.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a21d830e78df0a515db2b3d2f5570610f5e6bd2e27749770e8bb7b524b89b450", size = 11634535 },- { url = "https://files.pythonhosted.org/packages/a4/1e/1bac1a839d12e6a82ec6cb40cda2edde64a2013a66963293696bbf31fbbb/pandas-2.3.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2e3ebdb170b5ef78f19bfb71b0dc5dc58775032361fa188e814959b74d726dd5", size = 12121582 },- { url = "https://files.pythonhosted.org/packages/44/91/483de934193e12a3b1d6ae7c8645d083ff88dec75f46e827562f1e4b4da6/pandas-2.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d051c0e065b94b7a3cea50eb1ec32e912cd96dba41647eb24104b6c6c14c5788", size = 12699963 },- { url = "https://files.pythonhosted.org/packages/70/44/5191d2e4026f86a2a109053e194d3ba7a31a2d10a9c2348368c63ed4e85a/pandas-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3869faf4bd07b3b66a9f462417d0ca3a9df29a9f6abd5d0d0dbab15dac7abe87", size = 13202175 },+ { name = "numpy", marker = "python_full_version < '3.14'" },+ { name = "python-dateutil", marker = "python_full_version < '3.14'" },+ { name = "tzdata", marker = "(python_full_version < '3.14' and sys_platform == 'emscripten') or (python_full_version < '3.14' and sys_platform == 'win32')" },+]+sdist = { url = "https://files.pythonhosted.org/packages/2e/0c/b28ed414f080ee0ad153f848586d61d1878f91689950f037f976ce15f6c8/pandas-3.0.1.tar.gz", hash = "sha256:4186a699674af418f655dbd420ed87f50d56b4cd6603784279d9eef6627823c8", size = 4641901, upload-time = "2026-02-17T22:20:16.434Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/ff/07/c7087e003ceee9b9a82539b40414ec557aa795b584a1a346e89180853d79/pandas-3.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:de09668c1bf3b925c07e5762291602f0d789eca1b3a781f99c1c78f6cac0e7ea", size = 10323380, upload-time = "2026-02-17T22:18:16.133Z" },+ { url = "https://files.pythonhosted.org/packages/c1/27/90683c7122febeefe84a56f2cde86a9f05f68d53885cebcc473298dfc33e/pandas-3.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:24ba315ba3d6e5806063ac6eb717504e499ce30bd8c236d8693a5fd3f084c796", size = 9923455, upload-time = "2026-02-17T22:18:19.13Z" },+ { url = "https://files.pythonhosted.org/packages/0e/f1/ed17d927f9950643bc7631aa4c99ff0cc83a37864470bc419345b656a41f/pandas-3.0.1-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:406ce835c55bac912f2a0dcfaf27c06d73c6b04a5dde45f1fd3169ce31337389", size = 10753464, upload-time = "2026-02-17T22:18:21.134Z" },+ { url = "https://files.pythonhosted.org/packages/2e/7c/870c7e7daec2a6c7ff2ac9e33b23317230d4e4e954b35112759ea4a924a7/pandas-3.0.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:830994d7e1f31dd7e790045235605ab61cff6c94defc774547e8b7fdfbff3dc7", size = 11255234, upload-time = "2026-02-17T22:18:24.175Z" },+ { url = "https://files.pythonhosted.org/packages/5c/39/3653fe59af68606282b989c23d1a543ceba6e8099cbcc5f1d506a7bae2aa/pandas-3.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a64ce8b0f2de1d2efd2ae40b0abe7f8ae6b29fbfb3812098ed5a6f8e235ad9bf", size = 11767299, upload-time = "2026-02-17T22:18:26.824Z" },+ { url = "https://files.pythonhosted.org/packages/9b/31/1daf3c0c94a849c7a8dab8a69697b36d313b229918002ba3e409265c7888/pandas-3.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9832c2c69da24b602c32e0c7b1b508a03949c18ba08d4d9f1c1033426685b447", size = 12333292, upload-time = "2026-02-17T22:18:28.996Z" },+ { url = "https://files.pythonhosted.org/packages/1f/67/af63f83cd6ca603a00fe8530c10a60f0879265b8be00b5930e8e78c5b30b/pandas-3.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:84f0904a69e7365f79a0c77d3cdfccbfb05bf87847e3a51a41e1426b0edb9c79", size = 9892176, upload-time = "2026-02-17T22:18:31.79Z" },+ { url = "https://files.pythonhosted.org/packages/79/ab/9c776b14ac4b7b4140788eca18468ea39894bc7340a408f1d1e379856a6b/pandas-3.0.1-cp311-cp311-win_arm64.whl", hash = "sha256:4a68773d5a778afb31d12e34f7dd4612ab90de8c6fb1d8ffe5d4a03b955082a1", size = 9151328, upload-time = "2026-02-17T22:18:35.721Z" },+ { url = "https://files.pythonhosted.org/packages/37/51/b467209c08dae2c624873d7491ea47d2b47336e5403309d433ea79c38571/pandas-3.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:476f84f8c20c9f5bc47252b66b4bb25e1a9fc2fa98cead96744d8116cb85771d", size = 10344357, upload-time = "2026-02-17T22:18:38.262Z" },+ { url = "https://files.pythonhosted.org/packages/7c/f1/e2567ffc8951ab371db2e40b2fe068e36b81d8cf3260f06ae508700e5504/pandas-3.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0ab749dfba921edf641d4036c4c21c0b3ea70fea478165cb98a998fb2a261955", size = 9884543, upload-time = "2026-02-17T22:18:41.476Z" },+ { url = "https://files.pythonhosted.org/packages/d7/39/327802e0b6d693182403c144edacbc27eb82907b57062f23ef5a4c4a5ea7/pandas-3.0.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8e36891080b87823aff3640c78649b91b8ff6eea3c0d70aeabd72ea43ab069b", size = 10396030, upload-time = "2026-02-17T22:18:43.822Z" },+ { url = "https://files.pythonhosted.org/packages/3d/fe/89d77e424365280b79d99b3e1e7d606f5165af2f2ecfaf0c6d24c799d607/pandas-3.0.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:532527a701281b9dd371e2f582ed9094f4c12dd9ffb82c0c54ee28d8ac9520c4", size = 10876435, upload-time = "2026-02-17T22:18:45.954Z" },+ { url = "https://files.pythonhosted.org/packages/b5/a6/2a75320849dd154a793f69c951db759aedb8d1dd3939eeacda9bdcfa1629/pandas-3.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:356e5c055ed9b0da1580d465657bc7d00635af4fd47f30afb23025352ba764d1", size = 11405133, upload-time = "2026-02-17T22:18:48.533Z" },+ { url = "https://files.pythonhosted.org/packages/58/53/1d68fafb2e02d7881df66aa53be4cd748d25cbe311f3b3c85c93ea5d30ca/pandas-3.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9d810036895f9ad6345b8f2a338dd6998a74e8483847403582cab67745bff821", size = 11932065, upload-time = "2026-02-17T22:18:50.837Z" },+ { url = "https://files.pythonhosted.org/packages/75/08/67cc404b3a966b6df27b38370ddd96b3b023030b572283d035181854aac5/pandas-3.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:536232a5fe26dd989bd633e7a0c450705fdc86a207fec7254a55e9a22950fe43", size = 9741627, upload-time = "2026-02-17T22:18:53.905Z" },+ { url = "https://files.pythonhosted.org/packages/86/4f/caf9952948fb00d23795f09b893d11f1cacb384e666854d87249530f7cbe/pandas-3.0.1-cp312-cp312-win_arm64.whl", hash = "sha256:0f463ebfd8de7f326d38037c7363c6dacb857c5881ab8961fb387804d6daf2f7", size = 9052483, upload-time = "2026-02-17T22:18:57.31Z" },+ { url = "https://files.pythonhosted.org/packages/0b/48/aad6ec4f8d007534c091e9a7172b3ec1b1ee6d99a9cbb936b5eab6c6cf58/pandas-3.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5272627187b5d9c20e55d27caf5f2cd23e286aba25cadf73c8590e432e2b7262", size = 10317509, upload-time = "2026-02-17T22:18:59.498Z" },+ { url = "https://files.pythonhosted.org/packages/a8/14/5990826f779f79148ae9d3a2c39593dc04d61d5d90541e71b5749f35af95/pandas-3.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:661e0f665932af88c7877f31da0dc743fe9c8f2524bdffe23d24fdcb67ef9d56", size = 9860561, upload-time = "2026-02-17T22:19:02.265Z" },+ { url = "https://files.pythonhosted.org/packages/fa/80/f01ff54664b6d70fed71475543d108a9b7c888e923ad210795bef04ffb7d/pandas-3.0.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:75e6e292ff898679e47a2199172593d9f6107fd2dd3617c22c2946e97d5df46e", size = 10365506, upload-time = "2026-02-17T22:19:05.017Z" },+ { url = "https://files.pythonhosted.org/packages/f2/85/ab6d04733a7d6ff32bfc8382bf1b07078228f5d6ebec5266b91bfc5c4ff7/pandas-3.0.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1ff8cf1d2896e34343197685f432450ec99a85ba8d90cce2030c5eee2ef98791", size = 10873196, upload-time = "2026-02-17T22:19:07.204Z" },+ { url = "https://files.pythonhosted.org/packages/48/a9/9301c83d0b47c23ac5deab91c6b39fd98d5b5db4d93b25df8d381451828f/pandas-3.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eca8b4510f6763f3d37359c2105df03a7a221a508f30e396a51d0713d462e68a", size = 11370859, upload-time = "2026-02-17T22:19:09.436Z" },+ { url = "https://files.pythonhosted.org/packages/59/fe/0c1fc5bd2d29c7db2ab372330063ad555fb83e08422829c785f5ec2176ca/pandas-3.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:06aff2ad6f0b94a17822cf8b83bbb563b090ed82ff4fe7712db2ce57cd50d9b8", size = 11924584, upload-time = "2026-02-17T22:19:11.562Z" },+ { url = "https://files.pythonhosted.org/packages/d6/7d/216a1588b65a7aa5f4535570418a599d943c85afb1d95b0876fc00aa1468/pandas-3.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:9fea306c783e28884c29057a1d9baa11a349bbf99538ec1da44c8476563d1b25", size = 9742769, upload-time = "2026-02-17T22:19:13.926Z" },+ { url = "https://files.pythonhosted.org/packages/c4/cb/810a22a6af9a4e97c8ab1c946b47f3489c5bca5adc483ce0ffc84c9cc768/pandas-3.0.1-cp313-cp313-win_arm64.whl", hash = "sha256:a8d37a43c52917427e897cb2e429f67a449327394396a81034a4449b99afda59", size = 9043855, upload-time = "2026-02-17T22:19:16.09Z" },+ { url = "https://files.pythonhosted.org/packages/92/fa/423c89086cca1f039cf1253c3ff5b90f157b5b3757314aa635f6bf3e30aa/pandas-3.0.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d54855f04f8246ed7b6fc96b05d4871591143c46c0b6f4af874764ed0d2d6f06", size = 10752673, upload-time = "2026-02-17T22:19:18.304Z" },+ { url = "https://files.pythonhosted.org/packages/22/23/b5a08ec1f40020397f0faba72f1e2c11f7596a6169c7b3e800abff0e433f/pandas-3.0.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e1b677accee34a09e0dc2ce5624e4a58a1870ffe56fc021e9caf7f23cd7668f", size = 10404967, upload-time = "2026-02-17T22:19:20.726Z" },+ { url = "https://files.pythonhosted.org/packages/5c/81/94841f1bb4afdc2b52a99daa895ac2c61600bb72e26525ecc9543d453ebc/pandas-3.0.1-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a9cabbdcd03f1b6cd254d6dda8ae09b0252524be1592594c00b7895916cb1324", size = 10320575, upload-time = "2026-02-17T22:19:24.919Z" },+ { url = "https://files.pythonhosted.org/packages/0a/8b/2ae37d66a5342a83adadfd0cb0b4bf9c3c7925424dd5f40d15d6cfaa35ee/pandas-3.0.1-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ae2ab1f166668b41e770650101e7090824fd34d17915dd9cd479f5c5e0065e9", size = 10710921, upload-time = "2026-02-17T22:19:27.181Z" },+ { url = "https://files.pythonhosted.org/packages/a2/61/772b2e2757855e232b7ccf7cb8079a5711becb3a97f291c953def15a833f/pandas-3.0.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6bf0603c2e30e2cafac32807b06435f28741135cb8697eae8b28c7d492fc7d76", size = 11334191, upload-time = "2026-02-17T22:19:29.411Z" },+ { url = "https://files.pythonhosted.org/packages/1b/08/b16c6df3ef555d8495d1d265a7963b65be166785d28f06a350913a4fac78/pandas-3.0.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6c426422973973cae1f4a23e51d4ae85974f44871b24844e4f7de752dd877098", size = 11782256, upload-time = "2026-02-17T22:19:32.34Z" },+ { url = "https://files.pythonhosted.org/packages/55/80/178af0594890dee17e239fca96d3d8670ba0f5ff59b7d0439850924a9c09/pandas-3.0.1-cp313-cp313t-win_amd64.whl", hash = "sha256:b03f91ae8c10a85c1613102c7bef5229b5379f343030a3ccefeca8a33414cf35", size = 10485047, upload-time = "2026-02-17T22:19:34.605Z" },+ { url = "https://files.pythonhosted.org/packages/bb/8b/4bb774a998b97e6c2fd62a9e6cfdaae133b636fd1c468f92afb4ae9a447a/pandas-3.0.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:99d0f92ed92d3083d140bf6b97774f9f13863924cf3f52a70711f4e7588f9d0a", size = 10322465, upload-time = "2026-02-17T22:19:36.803Z" },+ { url = "https://files.pythonhosted.org/packages/72/3a/5b39b51c64159f470f1ca3b1c2a87da290657ca022f7cd11442606f607d1/pandas-3.0.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3b66857e983208654294bb6477b8a63dee26b37bdd0eb34d010556e91261784f", size = 9910632, upload-time = "2026-02-17T22:19:39.001Z" },+ { url = "https://files.pythonhosted.org/packages/4e/f7/b449ffb3f68c11da12fc06fbf6d2fa3a41c41e17d0284d23a79e1c13a7e4/pandas-3.0.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56cf59638bf24dc9bdf2154c81e248b3289f9a09a6d04e63608c159022352749", size = 10440535, upload-time = "2026-02-17T22:19:41.157Z" },+ { url = "https://files.pythonhosted.org/packages/55/77/6ea82043db22cb0f2bbfe7198da3544000ddaadb12d26be36e19b03a2dc5/pandas-3.0.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1a9f55e0f46951874b863d1f3906dcb57df2d9be5c5847ba4dfb55b2c815249", size = 10893940, upload-time = "2026-02-17T22:19:43.493Z" },+ { url = "https://files.pythonhosted.org/packages/03/30/f1b502a72468c89412c1b882a08f6eed8a4ee9dc033f35f65d0663df6081/pandas-3.0.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1849f0bba9c8a2fb0f691d492b834cc8dadf617e29015c66e989448d58d011ee", size = 11442711, upload-time = "2026-02-17T22:19:46.074Z" },+ { url = "https://files.pythonhosted.org/packages/0d/f0/ebb6ddd8fc049e98cabac5c2924d14d1dda26a20adb70d41ea2e428d3ec4/pandas-3.0.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c3d288439e11b5325b02ae6e9cc83e6805a62c40c5a6220bea9beb899c073b1c", size = 11963918, upload-time = "2026-02-17T22:19:48.838Z" },+ { url = "https://files.pythonhosted.org/packages/09/f8/8ce132104074f977f907442790eaae24e27bce3b3b454e82faa3237ff098/pandas-3.0.1-cp314-cp314-win_amd64.whl", hash = "sha256:93325b0fe372d192965f4cca88d97667f49557398bbf94abdda3bf1b591dbe66", size = 9862099, upload-time = "2026-02-17T22:19:51.081Z" },+ { url = "https://files.pythonhosted.org/packages/e6/b7/6af9aac41ef2456b768ef0ae60acf8abcebb450a52043d030a65b4b7c9bd/pandas-3.0.1-cp314-cp314-win_arm64.whl", hash = "sha256:97ca08674e3287c7148f4858b01136f8bdfe7202ad25ad04fec602dd1d29d132", size = 9185333, upload-time = "2026-02-17T22:19:53.266Z" },+ { url = "https://files.pythonhosted.org/packages/66/fc/848bb6710bc6061cb0c5badd65b92ff75c81302e0e31e496d00029fe4953/pandas-3.0.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:58eeb1b2e0fb322befcf2bbc9ba0af41e616abadb3d3414a6bc7167f6cbfce32", size = 10772664, upload-time = "2026-02-17T22:19:55.806Z" },+ { url = "https://files.pythonhosted.org/packages/69/5c/866a9bbd0f79263b4b0db6ec1a341be13a1473323f05c122388e0f15b21d/pandas-3.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:cd9af1276b5ca9e298bd79a26bda32fa9cc87ed095b2a9a60978d2ca058eaf87", size = 10421286, upload-time = "2026-02-17T22:19:58.091Z" },+ { url = "https://files.pythonhosted.org/packages/51/a4/2058fb84fb1cfbfb2d4a6d485e1940bb4ad5716e539d779852494479c580/pandas-3.0.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94f87a04984d6b63788327cd9f79dda62b7f9043909d2440ceccf709249ca988", size = 10342050, upload-time = "2026-02-17T22:20:01.376Z" },+ { url = "https://files.pythonhosted.org/packages/22/1b/674e89996cc4be74db3c4eb09240c4bb549865c9c3f5d9b086ff8fcfbf00/pandas-3.0.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85fe4c4df62e1e20f9db6ebfb88c844b092c22cd5324bdcf94bfa2fc1b391221", size = 10740055, upload-time = "2026-02-17T22:20:04.328Z" },+ { url = "https://files.pythonhosted.org/packages/d0/f8/e954b750764298c22fa4614376531fe63c521ef517e7059a51f062b87dca/pandas-3.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:331ca75a2f8672c365ae25c0b29e46f5ac0c6551fdace8eec4cd65e4fac271ff", size = 11357632, upload-time = "2026-02-17T22:20:06.647Z" },+ { url = "https://files.pythonhosted.org/packages/6d/02/c6e04b694ffd68568297abd03588b6d30295265176a5c01b7459d3bc35a3/pandas-3.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:15860b1fdb1973fffade772fdb931ccf9b2f400a3f5665aef94a00445d7d8dd5", size = 11810974, upload-time = "2026-02-17T22:20:08.946Z" },+ { url = "https://files.pythonhosted.org/packages/89/41/d7dfb63d2407f12055215070c42fc6ac41b66e90a2946cdc5e759058398b/pandas-3.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:44f1364411d5670efa692b146c748f4ed013df91ee91e9bec5677fb1fd58b937", size = 10884622, upload-time = "2026-02-17T22:20:11.711Z" },+ { url = "https://files.pythonhosted.org/packages/68/b0/34937815889fa982613775e4b97fddd13250f11012d769949c5465af2150/pandas-3.0.1-cp314-cp314t-win_arm64.whl", hash = "sha256:108dd1790337a494aa80e38def654ca3f0968cf4f362c85f44c15e471667102d", size = 9452085, upload-time = "2026-02-17T22:20:14.331Z" },+]++[[package]]+name = "pastel"+version = "0.2.1"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/76/f1/4594f5e0fcddb6953e5b8fe00da8c317b8b41b547e2b3ae2da7512943c62/pastel-0.2.1.tar.gz", hash = "sha256:e6581ac04e973cac858828c6202c1e1e81fee1dc7de7683f3e1ffe0bfd8a573d", size = 7555, upload-time = "2020-09-16T19:21:12.43Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/aa/18/a8444036c6dd65ba3624c63b734d3ba95ba63ace513078e1580590075d21/pastel-0.2.1-py2.py3-none-any.whl", hash = "sha256:4349225fcdf6c2bb34d483e523475de5bb04a5c10ef711263452cb37d7dd4364", size = 5955, upload-time = "2020-09-16T19:21:11.409Z" },][[package]]name = "pefile"-version = "2023.2.7"+version = "2024.8.26"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/78/c5/3b3c62223f72e2360737fd2a57c30e5b2adecd85e70276879609a7403334/pefile-2023.2.7.tar.gz", hash = "sha256:82e6114004b3d6911c77c3953e3838654b04511b8b66e8583db70c65998017dc", size = 74854 }+sdist = { url = "https://files.pythonhosted.org/packages/03/4f/2750f7f6f025a1507cd3b7218691671eecfd0bbebebe8b39aa0fe1d360b8/pefile-2024.8.26.tar.gz", hash = "sha256:3ff6c5d8b43e8c37bb6e6dd5085658d658a7a0bdcd20b6a07b1fcfc1c4e9d632", size = 76008, upload-time = "2024-08-26T20:58:38.155Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/55/26/d0ad8b448476d0a1e8d3ea5622dc77b916db84c6aa3cb1e1c0965af948fc/pefile-2023.2.7-py3-none-any.whl", hash = "sha256:da185cd2af68c08a6cd4481f7325ed600a88f6a813bad9dea07ab3ef73d8d8d6", size = 71791 },+ { url = "https://files.pythonhosted.org/packages/54/16/12b82f791c7f50ddec566873d5bdd245baa1491bac11d15ffb98aecc8f8b/pefile-2024.8.26-py3-none-any.whl", hash = "sha256:76f8b485dcd3b1bb8166f1128d395fa3d87af26360c2358fb75b80019b957c6f", size = 74766, upload-time = "2024-08-26T21:01:02.632Z" },][[package]]name = "pillow"-version = "12.0.0"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/cace85a1b0c9775a9f8f5d5423c8261c858760e2466c79b2dd184638b056/pillow-12.0.0.tar.gz", hash = "sha256:87d4f8125c9988bfbed67af47dd7a953e2fc7b0cc1e7800ec6d2080d490bb353", size = 47008828 }-wheels = [- { url = "https://files.pythonhosted.org/packages/0e/5a/a2f6773b64edb921a756eb0729068acad9fc5208a53f4a349396e9436721/pillow-12.0.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0fd00cac9c03256c8b2ff58f162ebcd2587ad3e1f2e397eab718c47e24d231cc", size = 5289798 },- { url = "https://files.pythonhosted.org/packages/2e/05/069b1f8a2e4b5a37493da6c5868531c3f77b85e716ad7a590ef87d58730d/pillow-12.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3475b96f5908b3b16c47533daaa87380c491357d197564e0ba34ae75c0f3257", size = 4650589 },- { url = "https://files.pythonhosted.org/packages/61/e3/2c820d6e9a36432503ead175ae294f96861b07600a7156154a086ba7111a/pillow-12.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:110486b79f2d112cf6add83b28b627e369219388f64ef2f960fef9ebaf54c642", size = 6230472 },- { url = "https://files.pythonhosted.org/packages/4f/89/63427f51c64209c5e23d4d52071c8d0f21024d3a8a487737caaf614a5795/pillow-12.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5269cc1caeedb67e6f7269a42014f381f45e2e7cd42d834ede3c703a1d915fe3", size = 8033887 },- { url = "https://files.pythonhosted.org/packages/f6/1b/c9711318d4901093c15840f268ad649459cd81984c9ec9887756cca049a5/pillow-12.0.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa5129de4e174daccbc59d0a3b6d20eaf24417d59851c07ebb37aeb02947987c", size = 6343964 },- { url = "https://files.pythonhosted.org/packages/41/1e/db9470f2d030b4995083044cd8738cdd1bf773106819f6d8ba12597d5352/pillow-12.0.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bee2a6db3a7242ea309aa7ee8e2780726fed67ff4e5b40169f2c940e7eb09227", size = 7034756 },- { url = "https://files.pythonhosted.org/packages/cc/b0/6177a8bdd5ee4ed87cba2de5a3cc1db55ffbbec6176784ce5bb75aa96798/pillow-12.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:90387104ee8400a7b4598253b4c406f8958f59fcf983a6cea2b50d59f7d63d0b", size = 6458075 },- { url = "https://files.pythonhosted.org/packages/bc/5e/61537aa6fa977922c6a03253a0e727e6e4a72381a80d63ad8eec350684f2/pillow-12.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bc91a56697869546d1b8f0a3ff35224557ae7f881050e99f615e0119bf934b4e", size = 7125955 },- { url = "https://files.pythonhosted.org/packages/1f/3d/d5033539344ee3cbd9a4d69e12e63ca3a44a739eb2d4c8da350a3d38edd7/pillow-12.0.0-cp311-cp311-win32.whl", hash = "sha256:27f95b12453d165099c84f8a8bfdfd46b9e4bda9e0e4b65f0635430027f55739", size = 6298440 },- { url = "https://files.pythonhosted.org/packages/4d/42/aaca386de5cc8bd8a0254516957c1f265e3521c91515b16e286c662854c4/pillow-12.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:b583dc9070312190192631373c6c8ed277254aa6e6084b74bdd0a6d3b221608e", size = 6999256 },- { url = "https://files.pythonhosted.org/packages/ba/f1/9197c9c2d5708b785f631a6dfbfa8eb3fb9672837cb92ae9af812c13b4ed/pillow-12.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:759de84a33be3b178a64c8ba28ad5c135900359e85fb662bc6e403ad4407791d", size = 2436025 },- { url = "https://files.pythonhosted.org/packages/2c/90/4fcce2c22caf044e660a198d740e7fbc14395619e3cb1abad12192c0826c/pillow-12.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:53561a4ddc36facb432fae7a9d8afbfaf94795414f5cdc5fc52f28c1dca90371", size = 5249377 },- { url = "https://files.pythonhosted.org/packages/fd/e0/ed960067543d080691d47d6938ebccbf3976a931c9567ab2fbfab983a5dd/pillow-12.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:71db6b4c1653045dacc1585c1b0d184004f0d7e694c7b34ac165ca70c0838082", size = 4650343 },- { url = "https://files.pythonhosted.org/packages/e7/a1/f81fdeddcb99c044bf7d6faa47e12850f13cee0849537a7d27eeab5534d4/pillow-12.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2fa5f0b6716fc88f11380b88b31fe591a06c6315e955c096c35715788b339e3f", size = 6232981 },- { url = "https://files.pythonhosted.org/packages/88/e1/9098d3ce341a8750b55b0e00c03f1630d6178f38ac191c81c97a3b047b44/pillow-12.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:82240051c6ca513c616f7f9da06e871f61bfd7805f566275841af15015b8f98d", size = 8041399 },- { url = "https://files.pythonhosted.org/packages/a7/62/a22e8d3b602ae8cc01446d0c57a54e982737f44b6f2e1e019a925143771d/pillow-12.0.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55f818bd74fe2f11d4d7cbc65880a843c4075e0ac7226bc1a23261dbea531953", size = 6347740 },- { url = "https://files.pythonhosted.org/packages/4f/87/424511bdcd02c8d7acf9f65caa09f291a519b16bd83c3fb3374b3d4ae951/pillow-12.0.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b87843e225e74576437fd5b6a4c2205d422754f84a06942cfaf1dc32243e45a8", size = 7040201 },- { url = "https://files.pythonhosted.org/packages/dc/4d/435c8ac688c54d11755aedfdd9f29c9eeddf68d150fe42d1d3dbd2365149/pillow-12.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c607c90ba67533e1b2355b821fef6764d1dd2cbe26b8c1005ae84f7aea25ff79", size = 6462334 },- { url = "https://files.pythonhosted.org/packages/2b/f2/ad34167a8059a59b8ad10bc5c72d4d9b35acc6b7c0877af8ac885b5f2044/pillow-12.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:21f241bdd5080a15bc86d3466a9f6074a9c2c2b314100dd896ac81ee6db2f1ba", size = 7134162 },- { url = "https://files.pythonhosted.org/packages/0c/b1/a7391df6adacf0a5c2cf6ac1cf1fcc1369e7d439d28f637a847f8803beb3/pillow-12.0.0-cp312-cp312-win32.whl", hash = "sha256:dd333073e0cacdc3089525c7df7d39b211bcdf31fc2824e49d01c6b6187b07d0", size = 6298769 },- { url = "https://files.pythonhosted.org/packages/a2/0b/d87733741526541c909bbf159e338dcace4f982daac6e5a8d6be225ca32d/pillow-12.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:9fe611163f6303d1619bbcb653540a4d60f9e55e622d60a3108be0d5b441017a", size = 7001107 },- { url = "https://files.pythonhosted.org/packages/bc/96/aaa61ce33cc98421fb6088af2a03be4157b1e7e0e87087c888e2370a7f45/pillow-12.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:7dfb439562f234f7d57b1ac6bc8fe7f838a4bd49c79230e0f6a1da93e82f1fad", size = 2436012 },- { url = "https://files.pythonhosted.org/packages/62/f2/de993bb2d21b33a98d031ecf6a978e4b61da207bef02f7b43093774c480d/pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0869154a2d0546545cde61d1789a6524319fc1897d9ee31218eae7a60ccc5643", size = 4045493 },- { url = "https://files.pythonhosted.org/packages/0e/b6/bc8d0c4c9f6f111a783d045310945deb769b806d7574764234ffd50bc5ea/pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:a7921c5a6d31b3d756ec980f2f47c0cfdbce0fc48c22a39347a895f41f4a6ea4", size = 4120461 },- { url = "https://files.pythonhosted.org/packages/5d/57/d60d343709366a353dc56adb4ee1e7d8a2cc34e3fbc22905f4167cfec119/pillow-12.0.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:1ee80a59f6ce048ae13cda1abf7fbd2a34ab9ee7d401c46be3ca685d1999a399", size = 3576912 },- { url = "https://files.pythonhosted.org/packages/a4/a4/a0a31467e3f83b94d37568294b01d22b43ae3c5d85f2811769b9c66389dd/pillow-12.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c50f36a62a22d350c96e49ad02d0da41dbd17ddc2e29750dbdba4323f85eb4a5", size = 5249132 },- { url = "https://files.pythonhosted.org/packages/83/06/48eab21dd561de2914242711434c0c0eb992ed08ff3f6107a5f44527f5e9/pillow-12.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5193fde9a5f23c331ea26d0cf171fbf67e3f247585f50c08b3e205c7aeb4589b", size = 4650099 },- { url = "https://files.pythonhosted.org/packages/fc/bd/69ed99fd46a8dba7c1887156d3572fe4484e3f031405fcc5a92e31c04035/pillow-12.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bde737cff1a975b70652b62d626f7785e0480918dece11e8fef3c0cf057351c3", size = 6230808 },- { url = "https://files.pythonhosted.org/packages/ea/94/8fad659bcdbf86ed70099cb60ae40be6acca434bbc8c4c0d4ef356d7e0de/pillow-12.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a6597ff2b61d121172f5844b53f21467f7082f5fb385a9a29c01414463f93b07", size = 8037804 },- { url = "https://files.pythonhosted.org/packages/20/39/c685d05c06deecfd4e2d1950e9a908aa2ca8bc4e6c3b12d93b9cafbd7837/pillow-12.0.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b817e7035ea7f6b942c13aa03bb554fc44fea70838ea21f8eb31c638326584e", size = 6345553 },- { url = "https://files.pythonhosted.org/packages/38/57/755dbd06530a27a5ed74f8cb0a7a44a21722ebf318edbe67ddbd7fb28f88/pillow-12.0.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4f1231b7dec408e8670264ce63e9c71409d9583dd21d32c163e25213ee2a344", size = 7037729 },- { url = "https://files.pythonhosted.org/packages/ca/b6/7e94f4c41d238615674d06ed677c14883103dce1c52e4af16f000338cfd7/pillow-12.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6e51b71417049ad6ab14c49608b4a24d8fb3fe605e5dfabfe523b58064dc3d27", size = 6459789 },- { url = "https://files.pythonhosted.org/packages/9c/14/4448bb0b5e0f22dd865290536d20ec8a23b64e2d04280b89139f09a36bb6/pillow-12.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d120c38a42c234dc9a8c5de7ceaaf899cf33561956acb4941653f8bdc657aa79", size = 7130917 },- { url = "https://files.pythonhosted.org/packages/dd/ca/16c6926cc1c015845745d5c16c9358e24282f1e588237a4c36d2b30f182f/pillow-12.0.0-cp313-cp313-win32.whl", hash = "sha256:4cc6b3b2efff105c6a1656cfe59da4fdde2cda9af1c5e0b58529b24525d0a098", size = 6302391 },- { url = "https://files.pythonhosted.org/packages/6d/2a/dd43dcfd6dae9b6a49ee28a8eedb98c7d5ff2de94a5d834565164667b97b/pillow-12.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:4cf7fed4b4580601c4345ceb5d4cbf5a980d030fd5ad07c4d2ec589f95f09905", size = 7007477 },- { url = "https://files.pythonhosted.org/packages/77/f0/72ea067f4b5ae5ead653053212af05ce3705807906ba3f3e8f58ddf617e6/pillow-12.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:9f0b04c6b8584c2c193babcccc908b38ed29524b29dd464bc8801bf10d746a3a", size = 2435918 },- { url = "https://files.pythonhosted.org/packages/f5/5e/9046b423735c21f0487ea6cb5b10f89ea8f8dfbe32576fe052b5ba9d4e5b/pillow-12.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:7fa22993bac7b77b78cae22bad1e2a987ddf0d9015c63358032f84a53f23cdc3", size = 5251406 },- { url = "https://files.pythonhosted.org/packages/12/66/982ceebcdb13c97270ef7a56c3969635b4ee7cd45227fa707c94719229c5/pillow-12.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f135c702ac42262573fe9714dfe99c944b4ba307af5eb507abef1667e2cbbced", size = 4653218 },- { url = "https://files.pythonhosted.org/packages/16/b3/81e625524688c31859450119bf12674619429cab3119eec0e30a7a1029cb/pillow-12.0.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c85de1136429c524e55cfa4e033b4a7940ac5c8ee4d9401cc2d1bf48154bbc7b", size = 6266564 },- { url = "https://files.pythonhosted.org/packages/98/59/dfb38f2a41240d2408096e1a76c671d0a105a4a8471b1871c6902719450c/pillow-12.0.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:38df9b4bfd3db902c9c2bd369bcacaf9d935b2fff73709429d95cc41554f7b3d", size = 8069260 },- { url = "https://files.pythonhosted.org/packages/dc/3d/378dbea5cd1874b94c312425ca77b0f47776c78e0df2df751b820c8c1d6c/pillow-12.0.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d87ef5795da03d742bf49439f9ca4d027cde49c82c5371ba52464aee266699a", size = 6379248 },- { url = "https://files.pythonhosted.org/packages/84/b0/d525ef47d71590f1621510327acec75ae58c721dc071b17d8d652ca494d8/pillow-12.0.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aff9e4d82d082ff9513bdd6acd4f5bd359f5b2c870907d2b0a9c5e10d40c88fe", size = 7066043 },- { url = "https://files.pythonhosted.org/packages/61/2c/aced60e9cf9d0cde341d54bf7932c9ffc33ddb4a1595798b3a5150c7ec4e/pillow-12.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:8d8ca2b210ada074d57fcee40c30446c9562e542fc46aedc19baf758a93532ee", size = 6490915 },- { url = "https://files.pythonhosted.org/packages/ef/26/69dcb9b91f4e59f8f34b2332a4a0a951b44f547c4ed39d3e4dcfcff48f89/pillow-12.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:99a7f72fb6249302aa62245680754862a44179b545ded638cf1fef59befb57ef", size = 7157998 },- { url = "https://files.pythonhosted.org/packages/61/2b/726235842220ca95fa441ddf55dd2382b52ab5b8d9c0596fe6b3f23dafe8/pillow-12.0.0-cp313-cp313t-win32.whl", hash = "sha256:4078242472387600b2ce8d93ade8899c12bf33fa89e55ec89fe126e9d6d5d9e9", size = 6306201 },- { url = "https://files.pythonhosted.org/packages/c0/3d/2afaf4e840b2df71344ababf2f8edd75a705ce500e5dc1e7227808312ae1/pillow-12.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2c54c1a783d6d60595d3514f0efe9b37c8808746a66920315bfd34a938d7994b", size = 7013165 },- { url = "https://files.pythonhosted.org/packages/6f/75/3fa09aa5cf6ed04bee3fa575798ddf1ce0bace8edb47249c798077a81f7f/pillow-12.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:26d9f7d2b604cd23aba3e9faf795787456ac25634d82cd060556998e39c6fa47", size = 2437834 },- { url = "https://files.pythonhosted.org/packages/54/2a/9a8c6ba2c2c07b71bec92cf63e03370ca5e5f5c5b119b742bcc0cde3f9c5/pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:beeae3f27f62308f1ddbcfb0690bf44b10732f2ef43758f169d5e9303165d3f9", size = 4045531 },- { url = "https://files.pythonhosted.org/packages/84/54/836fdbf1bfb3d66a59f0189ff0b9f5f666cee09c6188309300df04ad71fa/pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d4827615da15cd59784ce39d3388275ec093ae3ee8d7f0c089b76fa87af756c2", size = 4120554 },- { url = "https://files.pythonhosted.org/packages/0d/cd/16aec9f0da4793e98e6b54778a5fbce4f375c6646fe662e80600b8797379/pillow-12.0.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:3e42edad50b6909089750e65c91aa09aaf1e0a71310d383f11321b27c224ed8a", size = 3576812 },- { url = "https://files.pythonhosted.org/packages/f6/b7/13957fda356dc46339298b351cae0d327704986337c3c69bb54628c88155/pillow-12.0.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:e5d8efac84c9afcb40914ab49ba063d94f5dbdf5066db4482c66a992f47a3a3b", size = 5252689 },- { url = "https://files.pythonhosted.org/packages/fc/f5/eae31a306341d8f331f43edb2e9122c7661b975433de5e447939ae61c5da/pillow-12.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:266cd5f2b63ff316d5a1bba46268e603c9caf5606d44f38c2873c380950576ad", size = 4650186 },- { url = "https://files.pythonhosted.org/packages/86/62/2a88339aa40c4c77e79108facbd307d6091e2c0eb5b8d3cf4977cfca2fe6/pillow-12.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58eea5ebe51504057dd95c5b77d21700b77615ab0243d8152793dc00eb4faf01", size = 6230308 },- { url = "https://files.pythonhosted.org/packages/c7/33/5425a8992bcb32d1cb9fa3dd39a89e613d09a22f2c8083b7bf43c455f760/pillow-12.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f13711b1a5ba512d647a0e4ba79280d3a9a045aaf7e0cc6fbe96b91d4cdf6b0c", size = 8039222 },- { url = "https://files.pythonhosted.org/packages/d8/61/3f5d3b35c5728f37953d3eec5b5f3e77111949523bd2dd7f31a851e50690/pillow-12.0.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6846bd2d116ff42cba6b646edf5bf61d37e5cbd256425fa089fee4ff5c07a99e", size = 6346657 },- { url = "https://files.pythonhosted.org/packages/3a/be/ee90a3d79271227e0f0a33c453531efd6ed14b2e708596ba5dd9be948da3/pillow-12.0.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c98fa880d695de164b4135a52fd2e9cd7b7c90a9d8ac5e9e443a24a95ef9248e", size = 7038482 },- { url = "https://files.pythonhosted.org/packages/44/34/a16b6a4d1ad727de390e9bd9f19f5f669e079e5826ec0f329010ddea492f/pillow-12.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa3ed2a29a9e9d2d488b4da81dcb54720ac3104a20bf0bd273f1e4648aff5af9", size = 6461416 },- { url = "https://files.pythonhosted.org/packages/b6/39/1aa5850d2ade7d7ba9f54e4e4c17077244ff7a2d9e25998c38a29749eb3f/pillow-12.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d034140032870024e6b9892c692fe2968493790dd57208b2c37e3fb35f6df3ab", size = 7131584 },- { url = "https://files.pythonhosted.org/packages/bf/db/4fae862f8fad0167073a7733973bfa955f47e2cac3dc3e3e6257d10fab4a/pillow-12.0.0-cp314-cp314-win32.whl", hash = "sha256:1b1b133e6e16105f524a8dec491e0586d072948ce15c9b914e41cdadd209052b", size = 6400621 },- { url = "https://files.pythonhosted.org/packages/2b/24/b350c31543fb0107ab2599464d7e28e6f856027aadda995022e695313d94/pillow-12.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:8dc232e39d409036af549c86f24aed8273a40ffa459981146829a324e0848b4b", size = 7142916 },- { url = "https://files.pythonhosted.org/packages/0f/9b/0ba5a6fd9351793996ef7487c4fdbde8d3f5f75dbedc093bb598648fddf0/pillow-12.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:d52610d51e265a51518692045e372a4c363056130d922a7351429ac9f27e70b0", size = 2523836 },- { url = "https://files.pythonhosted.org/packages/f5/7a/ceee0840aebc579af529b523d530840338ecf63992395842e54edc805987/pillow-12.0.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1979f4566bb96c1e50a62d9831e2ea2d1211761e5662afc545fa766f996632f6", size = 5255092 },- { url = "https://files.pythonhosted.org/packages/44/76/20776057b4bfd1aef4eeca992ebde0f53a4dce874f3ae693d0ec90a4f79b/pillow-12.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b2e4b27a6e15b04832fe9bf292b94b5ca156016bbc1ea9c2c20098a0320d6cf6", size = 4653158 },- { url = "https://files.pythonhosted.org/packages/82/3f/d9ff92ace07be8836b4e7e87e6a4c7a8318d47c2f1463ffcf121fc57d9cb/pillow-12.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fb3096c30df99fd01c7bf8e544f392103d0795b9f98ba71a8054bcbf56b255f1", size = 6267882 },- { url = "https://files.pythonhosted.org/packages/9f/7a/4f7ff87f00d3ad33ba21af78bfcd2f032107710baf8280e3722ceec28cda/pillow-12.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7438839e9e053ef79f7112c881cef684013855016f928b168b81ed5835f3e75e", size = 8071001 },- { url = "https://files.pythonhosted.org/packages/75/87/fcea108944a52dad8cca0715ae6247e271eb80459364a98518f1e4f480c1/pillow-12.0.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d5c411a8eaa2299322b647cd932586b1427367fd3184ffbb8f7a219ea2041ca", size = 6380146 },- { url = "https://files.pythonhosted.org/packages/91/52/0d31b5e571ef5fd111d2978b84603fce26aba1b6092f28e941cb46570745/pillow-12.0.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7e091d464ac59d2c7ad8e7e08105eaf9dafbc3883fd7265ffccc2baad6ac925", size = 7067344 },- { url = "https://files.pythonhosted.org/packages/7b/f4/2dd3d721f875f928d48e83bb30a434dee75a2531bca839bb996bb0aa5a91/pillow-12.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:792a2c0be4dcc18af9d4a2dfd8a11a17d5e25274a1062b0ec1c2d79c76f3e7f8", size = 6491864 },- { url = "https://files.pythonhosted.org/packages/30/4b/667dfcf3d61fc309ba5a15b141845cece5915e39b99c1ceab0f34bf1d124/pillow-12.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:afbefa430092f71a9593a99ab6a4e7538bc9eabbf7bf94f91510d3503943edc4", size = 7158911 },- { url = "https://files.pythonhosted.org/packages/a2/2f/16cabcc6426c32218ace36bf0d55955e813f2958afddbf1d391849fee9d1/pillow-12.0.0-cp314-cp314t-win32.whl", hash = "sha256:3830c769decf88f1289680a59d4f4c46c72573446352e2befec9a8512104fa52", size = 6408045 },- { url = "https://files.pythonhosted.org/packages/35/73/e29aa0c9c666cf787628d3f0dcf379f4791fba79f4936d02f8b37165bdf8/pillow-12.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:905b0365b210c73afb0ebe9101a32572152dfd1c144c7e28968a331b9217b94a", size = 7148282 },- { url = "https://files.pythonhosted.org/packages/c1/70/6b41bdcddf541b437bbb9f47f94d2db5d9ddef6c37ccab8c9107743748a4/pillow-12.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:99353a06902c2e43b43e8ff74ee65a7d90307d82370604746738a1e0661ccca7", size = 2525630 },- { url = "https://files.pythonhosted.org/packages/1d/b3/582327e6c9f86d037b63beebe981425d6811104cb443e8193824ef1a2f27/pillow-12.0.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b22bd8c974942477156be55a768f7aa37c46904c175be4e158b6a86e3a6b7ca8", size = 5215068 },- { url = "https://files.pythonhosted.org/packages/fd/d6/67748211d119f3b6540baf90f92fae73ae51d5217b171b0e8b5f7e5d558f/pillow-12.0.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:805ebf596939e48dbb2e4922a1d3852cfc25c38160751ce02da93058b48d252a", size = 4614994 },- { url = "https://files.pythonhosted.org/packages/2d/e1/f8281e5d844c41872b273b9f2c34a4bf64ca08905668c8ae730eedc7c9fa/pillow-12.0.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cae81479f77420d217def5f54b5b9d279804d17e982e0f2fa19b1d1e14ab5197", size = 5246639 },- { url = "https://files.pythonhosted.org/packages/94/5a/0d8ab8ffe8a102ff5df60d0de5af309015163bf710c7bb3e8311dd3b3ad0/pillow-12.0.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeaefa96c768fc66818730b952a862235d68825c178f1b3ffd4efd7ad2edcb7c", size = 6986839 },- { url = "https://files.pythonhosted.org/packages/20/2e/3434380e8110b76cd9eb00a363c484b050f949b4bbe84ba770bb8508a02c/pillow-12.0.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09f2d0abef9e4e2f349305a4f8cc784a8a6c2f58a8c4892eea13b10a943bd26e", size = 5313505 },- { url = "https://files.pythonhosted.org/packages/57/ca/5a9d38900d9d74785141d6580950fe705de68af735ff6e727cb911b64740/pillow-12.0.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bdee52571a343d721fb2eb3b090a82d959ff37fc631e3f70422e0c2e029f3e76", size = 5963654 },- { url = "https://files.pythonhosted.org/packages/95/7e/f896623c3c635a90537ac093c6a618ebe1a90d87206e42309cb5d98a1b9e/pillow-12.0.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:b290fd8aa38422444d4b50d579de197557f182ef1068b75f5aa8558638b8d0a5", size = 6997850 },+version = "12.1.1"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/1f/42/5c74462b4fd957fcd7b13b04fb3205ff8349236ea74c7c375766d6c82288/pillow-12.1.1.tar.gz", hash = "sha256:9ad8fa5937ab05218e2b6a4cff30295ad35afd2f83ac592e68c0d871bb0fdbc4", size = 46980264, upload-time = "2026-02-11T04:23:07.146Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/2b/46/5da1ec4a5171ee7bf1a0efa064aba70ba3d6e0788ce3f5acd1375d23c8c0/pillow-12.1.1-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:e879bb6cd5c73848ef3b2b48b8af9ff08c5b71ecda8048b7dd22d8a33f60be32", size = 5304084, upload-time = "2026-02-11T04:20:27.501Z" },+ { url = "https://files.pythonhosted.org/packages/78/93/a29e9bc02d1cf557a834da780ceccd54e02421627200696fcf805ebdc3fb/pillow-12.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:365b10bb9417dd4498c0e3b128018c4a624dc11c7b97d8cc54effe3b096f4c38", size = 4657866, upload-time = "2026-02-11T04:20:29.827Z" },+ { url = "https://files.pythonhosted.org/packages/13/84/583a4558d492a179d31e4aae32eadce94b9acf49c0337c4ce0b70e0a01f2/pillow-12.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d4ce8e329c93845720cd2014659ca67eac35f6433fd3050393d85f3ecef0dad5", size = 6232148, upload-time = "2026-02-11T04:20:31.329Z" },+ { url = "https://files.pythonhosted.org/packages/d5/e2/53c43334bbbb2d3b938978532fbda8e62bb6e0b23a26ce8592f36bcc4987/pillow-12.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc354a04072b765eccf2204f588a7a532c9511e8b9c7f900e1b64e3e33487090", size = 8038007, upload-time = "2026-02-11T04:20:34.225Z" },+ { url = "https://files.pythonhosted.org/packages/b8/a6/3d0e79c8a9d58150dd98e199d7c1c56861027f3829a3a60b3c2784190180/pillow-12.1.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e7976bf1910a8116b523b9f9f58bf410f3e8aa330cd9a2bb2953f9266ab49af", size = 6345418, upload-time = "2026-02-11T04:20:35.858Z" },+ { url = "https://files.pythonhosted.org/packages/a2/c8/46dfeac5825e600579157eea177be43e2f7ff4a99da9d0d0a49533509ac5/pillow-12.1.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:597bd9c8419bc7c6af5604e55847789b69123bbe25d65cc6ad3012b4f3c98d8b", size = 7034590, upload-time = "2026-02-11T04:20:37.91Z" },+ { url = "https://files.pythonhosted.org/packages/af/bf/e6f65d3db8a8bbfeaf9e13cc0417813f6319863a73de934f14b2229ada18/pillow-12.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2c1fc0f2ca5f96a3c8407e41cca26a16e46b21060fe6d5b099d2cb01412222f5", size = 6458655, upload-time = "2026-02-11T04:20:39.496Z" },+ { url = "https://files.pythonhosted.org/packages/f9/c2/66091f3f34a25894ca129362e510b956ef26f8fb67a0e6417bc5744e56f1/pillow-12.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:578510d88c6229d735855e1f278aa305270438d36a05031dfaae5067cc8eb04d", size = 7159286, upload-time = "2026-02-11T04:20:41.139Z" },+ { url = "https://files.pythonhosted.org/packages/7b/5a/24bc8eb526a22f957d0cec6243146744966d40857e3d8deb68f7902ca6c1/pillow-12.1.1-cp311-cp311-win32.whl", hash = "sha256:7311c0a0dcadb89b36b7025dfd8326ecfa36964e29913074d47382706e516a7c", size = 6328663, upload-time = "2026-02-11T04:20:43.184Z" },+ { url = "https://files.pythonhosted.org/packages/31/03/bef822e4f2d8f9d7448c133d0a18185d3cce3e70472774fffefe8b0ed562/pillow-12.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:fbfa2a7c10cc2623f412753cddf391c7f971c52ca40a3f65dc5039b2939e8563", size = 7031448, upload-time = "2026-02-11T04:20:44.696Z" },+ { url = "https://files.pythonhosted.org/packages/49/70/f76296f53610bd17b2e7d31728b8b7825e3ac3b5b3688b51f52eab7c0818/pillow-12.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:b81b5e3511211631b3f672a595e3221252c90af017e399056d0faabb9538aa80", size = 2453651, upload-time = "2026-02-11T04:20:46.243Z" },+ { url = "https://files.pythonhosted.org/packages/07/d3/8df65da0d4df36b094351dce696f2989bec731d4f10e743b1c5f4da4d3bf/pillow-12.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ab323b787d6e18b3d91a72fc99b1a2c28651e4358749842b8f8dfacd28ef2052", size = 5262803, upload-time = "2026-02-11T04:20:47.653Z" },+ { url = "https://files.pythonhosted.org/packages/d6/71/5026395b290ff404b836e636f51d7297e6c83beceaa87c592718747e670f/pillow-12.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:adebb5bee0f0af4909c30db0d890c773d1a92ffe83da908e2e9e720f8edf3984", size = 4657601, upload-time = "2026-02-11T04:20:49.328Z" },+ { url = "https://files.pythonhosted.org/packages/b1/2e/1001613d941c67442f745aff0f7cc66dd8df9a9c084eb497e6a543ee6f7e/pillow-12.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bb66b7cc26f50977108790e2456b7921e773f23db5630261102233eb355a3b79", size = 6234995, upload-time = "2026-02-11T04:20:51.032Z" },+ { url = "https://files.pythonhosted.org/packages/07/26/246ab11455b2549b9233dbd44d358d033a2f780fa9007b61a913c5b2d24e/pillow-12.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aee2810642b2898bb187ced9b349e95d2a7272930796e022efaf12e99dccd293", size = 8045012, upload-time = "2026-02-11T04:20:52.882Z" },+ { url = "https://files.pythonhosted.org/packages/b2/8b/07587069c27be7535ac1fe33874e32de118fbd34e2a73b7f83436a88368c/pillow-12.1.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a0b1cd6232e2b618adcc54d9882e4e662a089d5768cd188f7c245b4c8c44a397", size = 6349638, upload-time = "2026-02-11T04:20:54.444Z" },+ { url = "https://files.pythonhosted.org/packages/ff/79/6df7b2ee763d619cda2fb4fea498e5f79d984dae304d45a8999b80d6cf5c/pillow-12.1.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7aac39bcf8d4770d089588a2e1dd111cbaa42df5a94be3114222057d68336bd0", size = 7041540, upload-time = "2026-02-11T04:20:55.97Z" },+ { url = "https://files.pythonhosted.org/packages/2c/5e/2ba19e7e7236d7529f4d873bdaf317a318896bac289abebd4bb00ef247f0/pillow-12.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ab174cd7d29a62dd139c44bf74b698039328f45cb03b4596c43473a46656b2f3", size = 6462613, upload-time = "2026-02-11T04:20:57.542Z" },+ { url = "https://files.pythonhosted.org/packages/03/03/31216ec124bb5c3dacd74ce8efff4cc7f52643653bad4825f8f08c697743/pillow-12.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:339ffdcb7cbeaa08221cd401d517d4b1fe7a9ed5d400e4a8039719238620ca35", size = 7166745, upload-time = "2026-02-11T04:20:59.196Z" },+ { url = "https://files.pythonhosted.org/packages/1f/e7/7c4552d80052337eb28653b617eafdef39adfb137c49dd7e831b8dc13bc5/pillow-12.1.1-cp312-cp312-win32.whl", hash = "sha256:5d1f9575a12bed9e9eedd9a4972834b08c97a352bd17955ccdebfeca5913fa0a", size = 6328823, upload-time = "2026-02-11T04:21:01.385Z" },+ { url = "https://files.pythonhosted.org/packages/3d/17/688626d192d7261bbbf98846fc98995726bddc2c945344b65bec3a29d731/pillow-12.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:21329ec8c96c6e979cd0dfd29406c40c1d52521a90544463057d2aaa937d66a6", size = 7033367, upload-time = "2026-02-11T04:21:03.536Z" },+ { url = "https://files.pythonhosted.org/packages/ed/fe/a0ef1f73f939b0eca03ee2c108d0043a87468664770612602c63266a43c4/pillow-12.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:af9a332e572978f0218686636610555ae3defd1633597be015ed50289a03c523", size = 2453811, upload-time = "2026-02-11T04:21:05.116Z" },+ { url = "https://files.pythonhosted.org/packages/d5/11/6db24d4bd7685583caeae54b7009584e38da3c3d4488ed4cd25b439de486/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d242e8ac078781f1de88bf823d70c1a9b3c7950a44cdf4b7c012e22ccbcd8e4e", size = 4062689, upload-time = "2026-02-11T04:21:06.804Z" },+ { url = "https://files.pythonhosted.org/packages/33/c0/ce6d3b1fe190f0021203e0d9b5b99e57843e345f15f9ef22fcd43842fd21/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:02f84dfad02693676692746df05b89cf25597560db2857363a208e393429f5e9", size = 4138535, upload-time = "2026-02-11T04:21:08.452Z" },+ { url = "https://files.pythonhosted.org/packages/a0/c6/d5eb6a4fb32a3f9c21a8c7613ec706534ea1cf9f4b3663e99f0d83f6fca8/pillow-12.1.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:e65498daf4b583091ccbb2556c7000abf0f3349fcd57ef7adc9a84a394ed29f6", size = 3601364, upload-time = "2026-02-11T04:21:10.194Z" },+ { url = "https://files.pythonhosted.org/packages/14/a1/16c4b823838ba4c9c52c0e6bbda903a3fe5a1bdbf1b8eb4fff7156f3e318/pillow-12.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c6db3b84c87d48d0088943bf33440e0c42370b99b1c2a7989216f7b42eede60", size = 5262561, upload-time = "2026-02-11T04:21:11.742Z" },+ { url = "https://files.pythonhosted.org/packages/bb/ad/ad9dc98ff24f485008aa5cdedaf1a219876f6f6c42a4626c08bc4e80b120/pillow-12.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8b7e5304e34942bf62e15184219a7b5ad4ff7f3bb5cca4d984f37df1a0e1aee2", size = 4657460, upload-time = "2026-02-11T04:21:13.786Z" },+ { url = "https://files.pythonhosted.org/packages/9e/1b/f1a4ea9a895b5732152789326202a82464d5254759fbacae4deea3069334/pillow-12.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:18e5bddd742a44b7e6b1e773ab5db102bd7a94c32555ba656e76d319d19c3850", size = 6232698, upload-time = "2026-02-11T04:21:15.949Z" },+ { url = "https://files.pythonhosted.org/packages/95/f4/86f51b8745070daf21fd2e5b1fe0eb35d4db9ca26e6d58366562fb56a743/pillow-12.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc44ef1f3de4f45b50ccf9136999d71abb99dca7706bc75d222ed350b9fd2289", size = 8041706, upload-time = "2026-02-11T04:21:17.723Z" },+ { url = "https://files.pythonhosted.org/packages/29/9b/d6ecd956bb1266dd1045e995cce9b8d77759e740953a1c9aad9502a0461e/pillow-12.1.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a8eb7ed8d4198bccbd07058416eeec51686b498e784eda166395a23eb99138e", size = 6346621, upload-time = "2026-02-11T04:21:19.547Z" },+ { url = "https://files.pythonhosted.org/packages/71/24/538bff45bde96535d7d998c6fed1a751c75ac7c53c37c90dc2601b243893/pillow-12.1.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47b94983da0c642de92ced1702c5b6c292a84bd3a8e1d1702ff923f183594717", size = 7038069, upload-time = "2026-02-11T04:21:21.378Z" },+ { url = "https://files.pythonhosted.org/packages/94/0e/58cb1a6bc48f746bc4cb3adb8cabff73e2742c92b3bf7a220b7cf69b9177/pillow-12.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:518a48c2aab7ce596d3bf79d0e275661b846e86e4d0e7dec34712c30fe07f02a", size = 6460040, upload-time = "2026-02-11T04:21:23.148Z" },+ { url = "https://files.pythonhosted.org/packages/6c/57/9045cb3ff11eeb6c1adce3b2d60d7d299d7b273a2e6c8381a524abfdc474/pillow-12.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a550ae29b95c6dc13cf69e2c9dc5747f814c54eeb2e32d683e5e93af56caa029", size = 7164523, upload-time = "2026-02-11T04:21:25.01Z" },+ { url = "https://files.pythonhosted.org/packages/73/f2/9be9cb99f2175f0d4dbadd6616ce1bf068ee54a28277ea1bf1fbf729c250/pillow-12.1.1-cp313-cp313-win32.whl", hash = "sha256:a003d7422449f6d1e3a34e3dd4110c22148336918ddbfc6a32581cd54b2e0b2b", size = 6332552, upload-time = "2026-02-11T04:21:27.238Z" },+ { url = "https://files.pythonhosted.org/packages/3f/eb/b0834ad8b583d7d9d42b80becff092082a1c3c156bb582590fcc973f1c7c/pillow-12.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:344cf1e3dab3be4b1fa08e449323d98a2a3f819ad20f4b22e77a0ede31f0faa1", size = 7040108, upload-time = "2026-02-11T04:21:29.462Z" },+ { url = "https://files.pythonhosted.org/packages/d5/7d/fc09634e2aabdd0feabaff4a32f4a7d97789223e7c2042fd805ea4b4d2c2/pillow-12.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:5c0dd1636633e7e6a0afe7bf6a51a14992b7f8e60de5789018ebbdfae55b040a", size = 2453712, upload-time = "2026-02-11T04:21:31.072Z" },+ { url = "https://files.pythonhosted.org/packages/19/2a/b9d62794fc8a0dd14c1943df68347badbd5511103e0d04c035ffe5cf2255/pillow-12.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0330d233c1a0ead844fc097a7d16c0abff4c12e856c0b325f231820fee1f39da", size = 5264880, upload-time = "2026-02-11T04:21:32.865Z" },+ { url = "https://files.pythonhosted.org/packages/26/9d/e03d857d1347fa5ed9247e123fcd2a97b6220e15e9cb73ca0a8d91702c6e/pillow-12.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5dae5f21afb91322f2ff791895ddd8889e5e947ff59f71b46041c8ce6db790bc", size = 4660616, upload-time = "2026-02-11T04:21:34.97Z" },+ { url = "https://files.pythonhosted.org/packages/f7/ec/8a6d22afd02570d30954e043f09c32772bfe143ba9285e2fdb11284952cd/pillow-12.1.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2e0c664be47252947d870ac0d327fea7e63985a08794758aa8af5b6cb6ec0c9c", size = 6269008, upload-time = "2026-02-11T04:21:36.623Z" },+ { url = "https://files.pythonhosted.org/packages/3d/1d/6d875422c9f28a4a361f495a5f68d9de4a66941dc2c619103ca335fa6446/pillow-12.1.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:691ab2ac363b8217f7d31b3497108fb1f50faab2f75dfb03284ec2f217e87bf8", size = 8073226, upload-time = "2026-02-11T04:21:38.585Z" },+ { url = "https://files.pythonhosted.org/packages/a1/cd/134b0b6ee5eda6dc09e25e24b40fdafe11a520bc725c1d0bbaa5e00bf95b/pillow-12.1.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9e8064fb1cc019296958595f6db671fba95209e3ceb0c4734c9baf97de04b20", size = 6380136, upload-time = "2026-02-11T04:21:40.562Z" },+ { url = "https://files.pythonhosted.org/packages/7a/a9/7628f013f18f001c1b98d8fffe3452f306a70dc6aba7d931019e0492f45e/pillow-12.1.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:472a8d7ded663e6162dafdf20015c486a7009483ca671cece7a9279b512fcb13", size = 7067129, upload-time = "2026-02-11T04:21:42.521Z" },+ { url = "https://files.pythonhosted.org/packages/1e/f8/66ab30a2193b277785601e82ee2d49f68ea575d9637e5e234faaa98efa4c/pillow-12.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:89b54027a766529136a06cfebeecb3a04900397a3590fd252160b888479517bf", size = 6491807, upload-time = "2026-02-11T04:21:44.22Z" },+ { url = "https://files.pythonhosted.org/packages/da/0b/a877a6627dc8318fdb84e357c5e1a758c0941ab1ddffdafd231983788579/pillow-12.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:86172b0831b82ce4f7877f280055892b31179e1576aa00d0df3bb1bbf8c3e524", size = 7190954, upload-time = "2026-02-11T04:21:46.114Z" },+ { url = "https://files.pythonhosted.org/packages/83/43/6f732ff85743cf746b1361b91665d9f5155e1483817f693f8d57ea93147f/pillow-12.1.1-cp313-cp313t-win32.whl", hash = "sha256:44ce27545b6efcf0fdbdceb31c9a5bdea9333e664cda58a7e674bb74608b3986", size = 6336441, upload-time = "2026-02-11T04:21:48.22Z" },+ { url = "https://files.pythonhosted.org/packages/3b/44/e865ef3986611bb75bfabdf94a590016ea327833f434558801122979cd0e/pillow-12.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:a285e3eb7a5a45a2ff504e31f4a8d1b12ef62e84e5411c6804a42197c1cf586c", size = 7045383, upload-time = "2026-02-11T04:21:50.015Z" },+ { url = "https://files.pythonhosted.org/packages/a8/c6/f4fb24268d0c6908b9f04143697ea18b0379490cb74ba9e8d41b898bd005/pillow-12.1.1-cp313-cp313t-win_arm64.whl", hash = "sha256:cc7d296b5ea4d29e6570dabeaed58d31c3fea35a633a69679fb03d7664f43fb3", size = 2456104, upload-time = "2026-02-11T04:21:51.633Z" },+ { url = "https://files.pythonhosted.org/packages/03/d0/bebb3ffbf31c5a8e97241476c4cf8b9828954693ce6744b4a2326af3e16b/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:417423db963cb4be8bac3fc1204fe61610f6abeed1580a7a2cbb2fbda20f12af", size = 4062652, upload-time = "2026-02-11T04:21:53.19Z" },+ { url = "https://files.pythonhosted.org/packages/2d/c0/0e16fb0addda4851445c28f8350d8c512f09de27bbb0d6d0bbf8b6709605/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:b957b71c6b2387610f556a7eb0828afbe40b4a98036fc0d2acfa5a44a0c2036f", size = 4138823, upload-time = "2026-02-11T04:22:03.088Z" },+ { url = "https://files.pythonhosted.org/packages/6b/fb/6170ec655d6f6bb6630a013dd7cf7bc218423d7b5fa9071bf63dc32175ae/pillow-12.1.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:097690ba1f2efdeb165a20469d59d8bb03c55fb6621eb2041a060ae8ea3e9642", size = 3601143, upload-time = "2026-02-11T04:22:04.909Z" },+ { url = "https://files.pythonhosted.org/packages/59/04/dc5c3f297510ba9a6837cbb318b87dd2b8f73eb41a43cc63767f65cb599c/pillow-12.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2815a87ab27848db0321fb78c7f0b2c8649dee134b7f2b80c6a45c6831d75ccd", size = 5266254, upload-time = "2026-02-11T04:22:07.656Z" },+ { url = "https://files.pythonhosted.org/packages/05/30/5db1236b0d6313f03ebf97f5e17cda9ca060f524b2fcc875149a8360b21c/pillow-12.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f7ed2c6543bad5a7d5530eb9e78c53132f93dfa44a28492db88b41cdab885202", size = 4657499, upload-time = "2026-02-11T04:22:09.613Z" },+ { url = "https://files.pythonhosted.org/packages/6f/18/008d2ca0eb612e81968e8be0bbae5051efba24d52debf930126d7eaacbba/pillow-12.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:652a2c9ccfb556235b2b501a3a7cf3742148cd22e04b5625c5fe057ea3e3191f", size = 6232137, upload-time = "2026-02-11T04:22:11.434Z" },+ { url = "https://files.pythonhosted.org/packages/70/f1/f14d5b8eeb4b2cd62b9f9f847eb6605f103df89ef619ac68f92f748614ea/pillow-12.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d6e4571eedf43af33d0fc233a382a76e849badbccdf1ac438841308652a08e1f", size = 8042721, upload-time = "2026-02-11T04:22:13.321Z" },+ { url = "https://files.pythonhosted.org/packages/5a/d6/17824509146e4babbdabf04d8171491fa9d776f7061ff6e727522df9bd03/pillow-12.1.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b574c51cf7d5d62e9be37ba446224b59a2da26dc4c1bb2ecbe936a4fb1a7cb7f", size = 6347798, upload-time = "2026-02-11T04:22:15.449Z" },+ { url = "https://files.pythonhosted.org/packages/d1/ee/c85a38a9ab92037a75615aba572c85ea51e605265036e00c5b67dfafbfe2/pillow-12.1.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a37691702ed687799de29a518d63d4682d9016932db66d4e90c345831b02fb4e", size = 7039315, upload-time = "2026-02-11T04:22:17.24Z" },+ { url = "https://files.pythonhosted.org/packages/ec/f3/bc8ccc6e08a148290d7523bde4d9a0d6c981db34631390dc6e6ec34cacf6/pillow-12.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f95c00d5d6700b2b890479664a06e754974848afaae5e21beb4d83c106923fd0", size = 6462360, upload-time = "2026-02-11T04:22:19.111Z" },+ { url = "https://files.pythonhosted.org/packages/f6/ab/69a42656adb1d0665ab051eec58a41f169ad295cf81ad45406963105408f/pillow-12.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:559b38da23606e68681337ad74622c4dbba02254fc9cb4488a305dd5975c7eeb", size = 7165438, upload-time = "2026-02-11T04:22:21.041Z" },+ { url = "https://files.pythonhosted.org/packages/02/46/81f7aa8941873f0f01d4b55cc543b0a3d03ec2ee30d617a0448bf6bd6dec/pillow-12.1.1-cp314-cp314-win32.whl", hash = "sha256:03edcc34d688572014ff223c125a3f77fb08091e4607e7745002fc214070b35f", size = 6431503, upload-time = "2026-02-11T04:22:22.833Z" },+ { url = "https://files.pythonhosted.org/packages/40/72/4c245f7d1044b67affc7f134a09ea619d4895333d35322b775b928180044/pillow-12.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:50480dcd74fa63b8e78235957d302d98d98d82ccbfac4c7e12108ba9ecbdba15", size = 7176748, upload-time = "2026-02-11T04:22:24.64Z" },+ { url = "https://files.pythonhosted.org/packages/e4/ad/8a87bdbe038c5c698736e3348af5c2194ffb872ea52f11894c95f9305435/pillow-12.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:5cb1785d97b0c3d1d1a16bc1d710c4a0049daefc4935f3a8f31f827f4d3d2e7f", size = 2544314, upload-time = "2026-02-11T04:22:26.685Z" },+ { url = "https://files.pythonhosted.org/packages/6c/9d/efd18493f9de13b87ede7c47e69184b9e859e4427225ea962e32e56a49bc/pillow-12.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1f90cff8aa76835cba5769f0b3121a22bd4eb9e6884cfe338216e557a9a548b8", size = 5268612, upload-time = "2026-02-11T04:22:29.884Z" },+ { url = "https://files.pythonhosted.org/packages/f8/f1/4f42eb2b388eb2ffc660dcb7f7b556c1015c53ebd5f7f754965ef997585b/pillow-12.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1f1be78ce9466a7ee64bfda57bdba0f7cc499d9794d518b854816c41bf0aa4e9", size = 4660567, upload-time = "2026-02-11T04:22:31.799Z" },+ { url = "https://files.pythonhosted.org/packages/01/54/df6ef130fa43e4b82e32624a7b821a2be1c5653a5fdad8469687a7db4e00/pillow-12.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:42fc1f4677106188ad9a55562bbade416f8b55456f522430fadab3cef7cd4e60", size = 6269951, upload-time = "2026-02-11T04:22:33.921Z" },+ { url = "https://files.pythonhosted.org/packages/a9/48/618752d06cc44bb4aae8ce0cd4e6426871929ed7b46215638088270d9b34/pillow-12.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98edb152429ab62a1818039744d8fbb3ccab98a7c29fc3d5fcef158f3f1f68b7", size = 8074769, upload-time = "2026-02-11T04:22:35.877Z" },+ { url = "https://files.pythonhosted.org/packages/c3/bd/f1d71eb39a72fa088d938655afba3e00b38018d052752f435838961127d8/pillow-12.1.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d470ab1178551dd17fdba0fef463359c41aaa613cdcd7ff8373f54be629f9f8f", size = 6381358, upload-time = "2026-02-11T04:22:37.698Z" },+ { url = "https://files.pythonhosted.org/packages/64/ef/c784e20b96674ed36a5af839305f55616f8b4f8aa8eeccf8531a6e312243/pillow-12.1.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6408a7b064595afcab0a49393a413732a35788f2a5092fdc6266952ed67de586", size = 7068558, upload-time = "2026-02-11T04:22:39.597Z" },+ { url = "https://files.pythonhosted.org/packages/73/cb/8059688b74422ae61278202c4e1ad992e8a2e7375227be0a21c6b87ca8d5/pillow-12.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5d8c41325b382c07799a3682c1c258469ea2ff97103c53717b7893862d0c98ce", size = 6493028, upload-time = "2026-02-11T04:22:42.73Z" },+ { url = "https://files.pythonhosted.org/packages/c6/da/e3c008ed7d2dd1f905b15949325934510b9d1931e5df999bb15972756818/pillow-12.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c7697918b5be27424e9ce568193efd13d925c4481dd364e43f5dff72d33e10f8", size = 7191940, upload-time = "2026-02-11T04:22:44.543Z" },+ { url = "https://files.pythonhosted.org/packages/01/4a/9202e8d11714c1fc5951f2e1ef362f2d7fbc595e1f6717971d5dd750e969/pillow-12.1.1-cp314-cp314t-win32.whl", hash = "sha256:d2912fd8114fc5545aa3a4b5576512f64c55a03f3ebcca4c10194d593d43ea36", size = 6438736, upload-time = "2026-02-11T04:22:46.347Z" },+ { url = "https://files.pythonhosted.org/packages/f3/ca/cbce2327eb9885476b3957b2e82eb12c866a8b16ad77392864ad601022ce/pillow-12.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:4ceb838d4bd9dab43e06c363cab2eebf63846d6a4aeaea283bbdfd8f1a8ed58b", size = 7182894, upload-time = "2026-02-11T04:22:48.114Z" },+ { url = "https://files.pythonhosted.org/packages/ec/d2/de599c95ba0a973b94410477f8bf0b6f0b5e67360eb89bcb1ad365258beb/pillow-12.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:7b03048319bfc6170e93bd60728a1af51d3dd7704935feb228c4d4faab35d334", size = 2546446, upload-time = "2026-02-11T04:22:50.342Z" },+ { url = "https://files.pythonhosted.org/packages/56/11/5d43209aa4cb58e0cc80127956ff1796a68b928e6324bbf06ef4db34367b/pillow-12.1.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:600fd103672b925fe62ed08e0d874ea34d692474df6f4bf7ebe148b30f89f39f", size = 5228606, upload-time = "2026-02-11T04:22:52.106Z" },+ { url = "https://files.pythonhosted.org/packages/5f/d5/3b005b4e4fda6698b371fa6c21b097d4707585d7db99e98d9b0b87ac612a/pillow-12.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:665e1b916b043cef294bc54d47bf02d87e13f769bc4bc5fa225a24b3a6c5aca9", size = 4622321, upload-time = "2026-02-11T04:22:53.827Z" },+ { url = "https://files.pythonhosted.org/packages/df/36/ed3ea2d594356fd8037e5a01f6156c74bc8d92dbb0fa60746cc96cabb6e8/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:495c302af3aad1ca67420ddd5c7bd480c8867ad173528767d906428057a11f0e", size = 5247579, upload-time = "2026-02-11T04:22:56.094Z" },+ { url = "https://files.pythonhosted.org/packages/54/9a/9cc3e029683cf6d20ae5085da0dafc63148e3252c2f13328e553aaa13cfb/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8fd420ef0c52c88b5a035a0886f367748c72147b2b8f384c9d12656678dfdfa9", size = 6989094, upload-time = "2026-02-11T04:22:58.288Z" },+ { url = "https://files.pythonhosted.org/packages/00/98/fc53ab36da80b88df0967896b6c4b4cd948a0dc5aa40a754266aa3ae48b3/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f975aa7ef9684ce7e2c18a3aa8f8e2106ce1e46b94ab713d156b2898811651d3", size = 5313850, upload-time = "2026-02-11T04:23:00.554Z" },+ { url = "https://files.pythonhosted.org/packages/30/02/00fa585abfd9fe9d73e5f6e554dc36cc2b842898cbfc46d70353dae227f8/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8089c852a56c2966cf18835db62d9b34fef7ba74c726ad943928d494fa7f4735", size = 5963343, upload-time = "2026-02-11T04:23:02.934Z" },+ { url = "https://files.pythonhosted.org/packages/f2/26/c56ce33ca856e358d27fda9676c055395abddb82c35ac0f593877ed4562e/pillow-12.1.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:cb9bb857b2d057c6dfc72ac5f3b44836924ba15721882ef103cecb40d002d80e", size = 7029880, upload-time = "2026-02-11T04:23:04.783Z" },+]++[[package]]+name = "pip"+version = "26.0.1"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/48/83/0d7d4e9efe3344b8e2fe25d93be44f64b65364d3c8d7bc6dc90198d5422e/pip-26.0.1.tar.gz", hash = "sha256:c4037d8a277c89b320abe636d59f91e6d0922d08a05b60e85e53b296613346d8", size = 1812747, upload-time = "2026-02-05T02:20:18.702Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/de/f0/c81e05b613866b76d2d1066490adf1a3dbc4ee9d9c839961c3fc8a6997af/pip-26.0.1-py3-none-any.whl", hash = "sha256:bdb1b08f4274833d62c1aa29e20907365a2ceb950410df15fc9521bad440122b", size = 1787723, upload-time = "2026-02-05T02:20:16.416Z" },+]++[[package]]+name = "pip-tools"+version = "7.5.3"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "build" },+ { name = "click" },+ { name = "pip" },+ { name = "pyproject-hooks" },+ { name = "setuptools" },+ { name = "wheel" },+]+sdist = { url = "https://files.pythonhosted.org/packages/4a/db/c6e2a02db5d98aa5f3250a305ce71e8bc3d1a022d1f47a54d14492ae23de/pip_tools-7.5.3.tar.gz", hash = "sha256:8fa364779ebc010cbfe17cb9de404457ac733e100840423f28f6955de7742d41", size = 176153, upload-time = "2026-02-11T18:25:07.72Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/6e/74/59906d876c6cb1137f42a137164f2fe683b06283cde84bfcf7f5dd43970b/pip_tools-7.5.3-py3-none-any.whl", hash = "sha256:3aac0c473240ae90db7213c033401f345b05197293ccbdd2704e52e7a783785e", size = 71359, upload-time = "2026-02-11T18:25:06.119Z" },][[package]]name = "pluggy"version = "1.6.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412 }+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538 },+ { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },][[package]]-name = "protobuf"-version = "4.25.8"+name = "poethepoet"+version = "0.41.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/df/01/34c8d2b6354906d728703cb9d546a0e534de479e25f1b581e4094c4a85cc/protobuf-4.25.8.tar.gz", hash = "sha256:6135cf8affe1fc6f76cced2641e4ea8d3e59518d1f24ae41ba97bcad82d397cd", size = 380920 }+dependencies = [+ { name = "pastel" },+ { name = "pyyaml" },+]+sdist = { url = "https://files.pythonhosted.org/packages/a8/b9/fa92286560f70eaa40d473ea48376d20c6c21f63627d33c6bb1c5e385175/poethepoet-0.41.0.tar.gz", hash = "sha256:dcaad621dc061f6a90b17d091bebb9ca043d67bfe9bd6aa4185aea3ebf7ff3e6", size = 87780, upload-time = "2026-02-08T20:45:36.061Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/45/ff/05f34305fe6b85bbfbecbc559d423a5985605cad5eda4f47eae9e9c9c5c5/protobuf-4.25.8-cp310-abi3-win32.whl", hash = "sha256:504435d831565f7cfac9f0714440028907f1975e4bed228e58e72ecfff58a1e0", size = 392745 },- { url = "https://files.pythonhosted.org/packages/08/35/8b8a8405c564caf4ba835b1fdf554da869954712b26d8f2a98c0e434469b/protobuf-4.25.8-cp310-abi3-win_amd64.whl", hash = "sha256:bd551eb1fe1d7e92c1af1d75bdfa572eff1ab0e5bf1736716814cdccdb2360f9", size = 413736 },- { url = "https://files.pythonhosted.org/packages/28/d7/ab27049a035b258dab43445eb6ec84a26277b16105b277cbe0a7698bdc6c/protobuf-4.25.8-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:ca809b42f4444f144f2115c4c1a747b9a404d590f18f37e9402422033e464e0f", size = 394537 },- { url = "https://files.pythonhosted.org/packages/bd/6d/a4a198b61808dd3d1ee187082ccc21499bc949d639feb948961b48be9a7e/protobuf-4.25.8-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:9ad7ef62d92baf5a8654fbb88dac7fa5594cfa70fd3440488a5ca3bfc6d795a7", size = 294005 },- { url = "https://files.pythonhosted.org/packages/d6/c6/c9deaa6e789b6fc41b88ccbdfe7a42d2b82663248b715f55aa77fbc00724/protobuf-4.25.8-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:83e6e54e93d2b696a92cad6e6efc924f3850f82b52e1563778dfab8b355101b0", size = 294924 },- { url = "https://files.pythonhosted.org/packages/0c/c1/6aece0ab5209981a70cd186f164c133fdba2f51e124ff92b73de7fd24d78/protobuf-4.25.8-py3-none-any.whl", hash = "sha256:15a0af558aa3b13efef102ae6e4f3efac06f1eea11afb3a57db2901447d9fb59", size = 156757 },+ { url = "https://files.pythonhosted.org/packages/5d/5e/0b83e0222ce5921b3f9081eeca8c6fb3e1cfd5ca0d06338adf93b28ce061/poethepoet-0.41.0-py3-none-any.whl", hash = "sha256:4bab9fd8271664c5d21407e8f12827daeb6aa484dc6cc7620f0c3b4e62b42ee4", size = 113590, upload-time = "2026-02-08T20:45:34.697Z" },][[package]]name = "psutil"version = "5.9.6"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/2d/01/beb7331fc6c8d1c49dd051e3611379bfe379e915c808e1301506027fce9d/psutil-5.9.6.tar.gz", hash = "sha256:e4b92ddcd7dd4cdd3f900180ea1e104932c7bce234fb88976e2a3b296441225a", size = 496866 }+sdist = { url = "https://files.pythonhosted.org/packages/2d/01/beb7331fc6c8d1c49dd051e3611379bfe379e915c808e1301506027fce9d/psutil-5.9.6.tar.gz", hash = "sha256:e4b92ddcd7dd4cdd3f900180ea1e104932c7bce234fb88976e2a3b296441225a", size = 496866, upload-time = "2023-10-15T09:08:46.623Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/f8/36/35b12441ba1bc6684c9215191f955415196ca57ca85d88e313bec7f2cf8e/psutil-5.9.6-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:c69596f9fc2f8acd574a12d5f8b7b1ba3765a641ea5d60fb4736bf3c08a8214a", size = 246101 },- { url = "https://files.pythonhosted.org/packages/61/c8/e684dea1912943347922ab5c05efc94b4ff3d7470038e8afbe3941ef9efe/psutil-5.9.6-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:92e0cc43c524834af53e9d3369245e6cc3b130e78e26100d1f63cdb0abeb3d3c", size = 280854 },- { url = "https://files.pythonhosted.org/packages/19/06/4e3fa3c1b79271e933c5ddbad3a48aa2c3d5f592a0fb7c037f3e0f619f4d/psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:748c9dd2583ed86347ed65d0035f45fa8c851e8d90354c122ab72319b5f366f4", size = 283614 },- { url = "https://files.pythonhosted.org/packages/06/ac/f31a0faf98267e63fc6ed046ad2aca68bd79521380026e92fd4921c869aa/psutil-5.9.6-cp37-abi3-win32.whl", hash = "sha256:a6f01f03bf1843280f4ad16f4bde26b817847b4c1a0db59bf6419807bc5ce05c", size = 248489 },- { url = "https://files.pythonhosted.org/packages/c5/b2/699c50fe0b0402a1ccb64ad71313bcb740e735008dd3ab9abeddbe148e45/psutil-5.9.6-cp37-abi3-win_amd64.whl", hash = "sha256:6e5fb8dc711a514da83098bc5234264e551ad980cec5f85dabf4d38ed6f15e9a", size = 252327 },- { url = "https://files.pythonhosted.org/packages/9e/cb/e4b83c27eea66bc255effc967053f6fce7c14906dd9b43a348ead9f0cfea/psutil-5.9.6-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:daecbcbd29b289aac14ece28eca6a3e60aa361754cf6da3dfb20d4d32b6c7f57", size = 246859 },+ { url = "https://files.pythonhosted.org/packages/f8/36/35b12441ba1bc6684c9215191f955415196ca57ca85d88e313bec7f2cf8e/psutil-5.9.6-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:c69596f9fc2f8acd574a12d5f8b7b1ba3765a641ea5d60fb4736bf3c08a8214a", size = 246101, upload-time = "2023-10-15T09:09:08.012Z" },+ { url = "https://files.pythonhosted.org/packages/61/c8/e684dea1912943347922ab5c05efc94b4ff3d7470038e8afbe3941ef9efe/psutil-5.9.6-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:92e0cc43c524834af53e9d3369245e6cc3b130e78e26100d1f63cdb0abeb3d3c", size = 280854, upload-time = "2023-10-15T09:09:09.832Z" },+ { url = "https://files.pythonhosted.org/packages/19/06/4e3fa3c1b79271e933c5ddbad3a48aa2c3d5f592a0fb7c037f3e0f619f4d/psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:748c9dd2583ed86347ed65d0035f45fa8c851e8d90354c122ab72319b5f366f4", size = 283614, upload-time = "2023-10-15T09:09:12.314Z" },+ { url = "https://files.pythonhosted.org/packages/06/ac/f31a0faf98267e63fc6ed046ad2aca68bd79521380026e92fd4921c869aa/psutil-5.9.6-cp37-abi3-win32.whl", hash = "sha256:a6f01f03bf1843280f4ad16f4bde26b817847b4c1a0db59bf6419807bc5ce05c", size = 248489, upload-time = "2023-10-15T09:09:19.912Z" },+ { url = "https://files.pythonhosted.org/packages/c5/b2/699c50fe0b0402a1ccb64ad71313bcb740e735008dd3ab9abeddbe148e45/psutil-5.9.6-cp37-abi3-win_amd64.whl", hash = "sha256:6e5fb8dc711a514da83098bc5234264e551ad980cec5f85dabf4d38ed6f15e9a", size = 252327, upload-time = "2023-10-15T09:09:32.052Z" },+ { url = "https://files.pythonhosted.org/packages/9e/cb/e4b83c27eea66bc255effc967053f6fce7c14906dd9b43a348ead9f0cfea/psutil-5.9.6-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:daecbcbd29b289aac14ece28eca6a3e60aa361754cf6da3dfb20d4d32b6c7f57", size = 246859, upload-time = "2023-10-15T09:09:34.494Z" },][[package]]name = "pyarrow"-version = "22.0.0"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/30/53/04a7fdc63e6056116c9ddc8b43bc28c12cdd181b85cbeadb79278475f3ae/pyarrow-22.0.0.tar.gz", hash = "sha256:3d600dc583260d845c7d8a6db540339dd883081925da2bd1c5cb808f720b3cd9", size = 1151151 }-wheels = [- { url = "https://files.pythonhosted.org/packages/2e/b7/18f611a8cdc43417f9394a3ccd3eace2f32183c08b9eddc3d17681819f37/pyarrow-22.0.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:3e294c5eadfb93d78b0763e859a0c16d4051fc1c5231ae8956d61cb0b5666f5a", size = 34272022 },- { url = "https://files.pythonhosted.org/packages/26/5c/f259e2526c67eb4b9e511741b19870a02363a47a35edbebc55c3178db22d/pyarrow-22.0.0-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:69763ab2445f632d90b504a815a2a033f74332997052b721002298ed6de40f2e", size = 35995834 },- { url = "https://files.pythonhosted.org/packages/50/8d/281f0f9b9376d4b7f146913b26fac0aa2829cd1ee7e997f53a27411bbb92/pyarrow-22.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:b41f37cabfe2463232684de44bad753d6be08a7a072f6a83447eeaf0e4d2a215", size = 45030348 },- { url = "https://files.pythonhosted.org/packages/f5/e5/53c0a1c428f0976bf22f513d79c73000926cb00b9c138d8e02daf2102e18/pyarrow-22.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:35ad0f0378c9359b3f297299c3309778bb03b8612f987399a0333a560b43862d", size = 47699480 },- { url = "https://files.pythonhosted.org/packages/95/e1/9dbe4c465c3365959d183e6345d0a8d1dc5b02ca3f8db4760b3bc834cf25/pyarrow-22.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8382ad21458075c2e66a82a29d650f963ce51c7708c7c0ff313a8c206c4fd5e8", size = 48011148 },- { url = "https://files.pythonhosted.org/packages/c5/b4/7caf5d21930061444c3cf4fa7535c82faf5263e22ce43af7c2759ceb5b8b/pyarrow-22.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1a812a5b727bc09c3d7ea072c4eebf657c2f7066155506ba31ebf4792f88f016", size = 50276964 },- { url = "https://files.pythonhosted.org/packages/ae/f3/cec89bd99fa3abf826f14d4e53d3d11340ce6f6af4d14bdcd54cd83b6576/pyarrow-22.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:ec5d40dd494882704fb876c16fa7261a69791e784ae34e6b5992e977bd2e238c", size = 28106517 },- { url = "https://files.pythonhosted.org/packages/af/63/ba23862d69652f85b615ca14ad14f3bcfc5bf1b99ef3f0cd04ff93fdad5a/pyarrow-22.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:bea79263d55c24a32b0d79c00a1c58bb2ee5f0757ed95656b01c0fb310c5af3d", size = 34211578 },- { url = "https://files.pythonhosted.org/packages/b1/d0/f9ad86fe809efd2bcc8be32032fa72e8b0d112b01ae56a053006376c5930/pyarrow-22.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:12fe549c9b10ac98c91cf791d2945e878875d95508e1a5d14091a7aaa66d9cf8", size = 35989906 },- { url = "https://files.pythonhosted.org/packages/b4/a8/f910afcb14630e64d673f15904ec27dd31f1e009b77033c365c84e8c1e1d/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:334f900ff08ce0423407af97e6c26ad5d4e3b0763645559ece6fbf3747d6a8f5", size = 45021677 },- { url = "https://files.pythonhosted.org/packages/13/95/aec81f781c75cd10554dc17a25849c720d54feafb6f7847690478dcf5ef8/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c6c791b09c57ed76a18b03f2631753a4960eefbbca80f846da8baefc6491fcfe", size = 47726315 },- { url = "https://files.pythonhosted.org/packages/bb/d4/74ac9f7a54cfde12ee42734ea25d5a3c9a45db78f9def949307a92720d37/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c3200cb41cdbc65156e5f8c908d739b0dfed57e890329413da2748d1a2cd1a4e", size = 47990906 },- { url = "https://files.pythonhosted.org/packages/2e/71/fedf2499bf7a95062eafc989ace56572f3343432570e1c54e6599d5b88da/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ac93252226cf288753d8b46280f4edf3433bf9508b6977f8dd8526b521a1bbb9", size = 50306783 },- { url = "https://files.pythonhosted.org/packages/68/ed/b202abd5a5b78f519722f3d29063dda03c114711093c1995a33b8e2e0f4b/pyarrow-22.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:44729980b6c50a5f2bfcc2668d36c569ce17f8b17bccaf470c4313dcbbf13c9d", size = 27972883 },- { url = "https://files.pythonhosted.org/packages/a6/d6/d0fac16a2963002fc22c8fa75180a838737203d558f0ed3b564c4a54eef5/pyarrow-22.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:e6e95176209257803a8b3d0394f21604e796dadb643d2f7ca21b66c9c0b30c9a", size = 34204629 },- { url = "https://files.pythonhosted.org/packages/c6/9c/1d6357347fbae062ad3f17082f9ebc29cc733321e892c0d2085f42a2212b/pyarrow-22.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:001ea83a58024818826a9e3f89bf9310a114f7e26dfe404a4c32686f97bd7901", size = 35985783 },- { url = "https://files.pythonhosted.org/packages/ff/c0/782344c2ce58afbea010150df07e3a2f5fdad299cd631697ae7bd3bac6e3/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:ce20fe000754f477c8a9125543f1936ea5b8867c5406757c224d745ed033e691", size = 45020999 },- { url = "https://files.pythonhosted.org/packages/1b/8b/5362443737a5307a7b67c1017c42cd104213189b4970bf607e05faf9c525/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e0a15757fccb38c410947df156f9749ae4a3c89b2393741a50521f39a8cf202a", size = 47724601 },- { url = "https://files.pythonhosted.org/packages/69/4d/76e567a4fc2e190ee6072967cb4672b7d9249ac59ae65af2d7e3047afa3b/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cedb9dd9358e4ea1d9bce3665ce0797f6adf97ff142c8e25b46ba9cdd508e9b6", size = 48001050 },- { url = "https://files.pythonhosted.org/packages/01/5e/5653f0535d2a1aef8223cee9d92944cb6bccfee5cf1cd3f462d7cb022790/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:252be4a05f9d9185bb8c18e83764ebcfea7185076c07a7a662253af3a8c07941", size = 50307877 },- { url = "https://files.pythonhosted.org/packages/2d/f8/1d0bd75bf9328a3b826e24a16e5517cd7f9fbf8d34a3184a4566ef5a7f29/pyarrow-22.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:a4893d31e5ef780b6edcaf63122df0f8d321088bb0dee4c8c06eccb1ca28d145", size = 27977099 },- { url = "https://files.pythonhosted.org/packages/90/81/db56870c997805bf2b0f6eeeb2d68458bf4654652dccdcf1bf7a42d80903/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:f7fe3dbe871294ba70d789be16b6e7e52b418311e166e0e3cba9522f0f437fb1", size = 34336685 },- { url = "https://files.pythonhosted.org/packages/1c/98/0727947f199aba8a120f47dfc229eeb05df15bcd7a6f1b669e9f882afc58/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:ba95112d15fd4f1105fb2402c4eab9068f0554435e9b7085924bcfaac2cc306f", size = 36032158 },- { url = "https://files.pythonhosted.org/packages/96/b4/9babdef9c01720a0785945c7cf550e4acd0ebcd7bdd2e6f0aa7981fa85e2/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c064e28361c05d72eed8e744c9605cbd6d2bb7481a511c74071fd9b24bc65d7d", size = 44892060 },- { url = "https://files.pythonhosted.org/packages/f8/ca/2f8804edd6279f78a37062d813de3f16f29183874447ef6d1aadbb4efa0f/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:6f9762274496c244d951c819348afbcf212714902742225f649cf02823a6a10f", size = 47504395 },- { url = "https://files.pythonhosted.org/packages/b9/f0/77aa5198fd3943682b2e4faaf179a674f0edea0d55d326d83cb2277d9363/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a9d9ffdc2ab696f6b15b4d1f7cec6658e1d788124418cb30030afbae31c64746", size = 48066216 },- { url = "https://files.pythonhosted.org/packages/79/87/a1937b6e78b2aff18b706d738c9e46ade5bfcf11b294e39c87706a0089ac/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ec1a15968a9d80da01e1d30349b2b0d7cc91e96588ee324ce1b5228175043e95", size = 50288552 },- { url = "https://files.pythonhosted.org/packages/60/ae/b5a5811e11f25788ccfdaa8f26b6791c9807119dffcf80514505527c384c/pyarrow-22.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:bba208d9c7decf9961998edf5c65e3ea4355d5818dd6cd0f6809bec1afb951cc", size = 28262504 },- { url = "https://files.pythonhosted.org/packages/bd/b0/0fa4d28a8edb42b0a7144edd20befd04173ac79819547216f8a9f36f9e50/pyarrow-22.0.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:9bddc2cade6561f6820d4cd73f99a0243532ad506bc510a75a5a65a522b2d74d", size = 34224062 },- { url = "https://files.pythonhosted.org/packages/0f/a8/7a719076b3c1be0acef56a07220c586f25cd24de0e3f3102b438d18ae5df/pyarrow-22.0.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:e70ff90c64419709d38c8932ea9fe1cc98415c4f87ea8da81719e43f02534bc9", size = 35990057 },- { url = "https://files.pythonhosted.org/packages/89/3c/359ed54c93b47fb6fe30ed16cdf50e3f0e8b9ccfb11b86218c3619ae50a8/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:92843c305330aa94a36e706c16209cd4df274693e777ca47112617db7d0ef3d7", size = 45068002 },- { url = "https://files.pythonhosted.org/packages/55/fc/4945896cc8638536ee787a3bd6ce7cec8ec9acf452d78ec39ab328efa0a1/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:6dda1ddac033d27421c20d7a7943eec60be44e0db4e079f33cc5af3b8280ccde", size = 47737765 },- { url = "https://files.pythonhosted.org/packages/cd/5e/7cb7edeb2abfaa1f79b5d5eb89432356155c8426f75d3753cbcb9592c0fd/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:84378110dd9a6c06323b41b56e129c504d157d1a983ce8f5443761eb5256bafc", size = 48048139 },- { url = "https://files.pythonhosted.org/packages/88/c6/546baa7c48185f5e9d6e59277c4b19f30f48c94d9dd938c2a80d4d6b067c/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:854794239111d2b88b40b6ef92aa478024d1e5074f364033e73e21e3f76b25e0", size = 50314244 },- { url = "https://files.pythonhosted.org/packages/3c/79/755ff2d145aafec8d347bf18f95e4e81c00127f06d080135dfc86aea417c/pyarrow-22.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:b883fe6fd85adad7932b3271c38ac289c65b7337c2c132e9569f9d3940620730", size = 28757501 },- { url = "https://files.pythonhosted.org/packages/0e/d2/237d75ac28ced3147912954e3c1a174df43a95f4f88e467809118a8165e0/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:7a820d8ae11facf32585507c11f04e3f38343c1e784c9b5a8b1da5c930547fe2", size = 34355506 },- { url = "https://files.pythonhosted.org/packages/1e/2c/733dfffe6d3069740f98e57ff81007809067d68626c5faef293434d11bd6/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:c6ec3675d98915bf1ec8b3c7986422682f7232ea76cad276f4c8abd5b7319b70", size = 36047312 },- { url = "https://files.pythonhosted.org/packages/7c/2b/29d6e3782dc1f299727462c1543af357a0f2c1d3c160ce199950d9ca51eb/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:3e739edd001b04f654b166204fc7a9de896cf6007eaff33409ee9e50ceaff754", size = 45081609 },- { url = "https://files.pythonhosted.org/packages/8d/42/aa9355ecc05997915af1b7b947a7f66c02dcaa927f3203b87871c114ba10/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:7388ac685cab5b279a41dfe0a6ccd99e4dbf322edfb63e02fc0443bf24134e91", size = 47703663 },- { url = "https://files.pythonhosted.org/packages/ee/62/45abedde480168e83a1de005b7b7043fd553321c1e8c5a9a114425f64842/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f633074f36dbc33d5c05b5dc75371e5660f1dbf9c8b1d95669def05e5425989c", size = 48066543 },- { url = "https://files.pythonhosted.org/packages/84/e9/7878940a5b072e4f3bf998770acafeae13b267f9893af5f6d4ab3904b67e/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4c19236ae2402a8663a2c8f21f1870a03cc57f0bef7e4b6eb3238cc82944de80", size = 50288838 },- { url = "https://files.pythonhosted.org/packages/7b/03/f335d6c52b4a4761bcc83499789a1e2e16d9d201a58c327a9b5cc9a41bd9/pyarrow-22.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0c34fe18094686194f204a3b1787a27456897d8a2d62caf84b61e8dfbc0252ae", size = 29185594 },+version = "23.0.1"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/88/22/134986a4cc224d593c1afde5494d18ff629393d74cc2eddb176669f234a4/pyarrow-23.0.1.tar.gz", hash = "sha256:b8c5873e33440b2bc2f4a79d2b47017a89c5a24116c055625e6f2ee50523f019", size = 1167336, upload-time = "2026-02-16T10:14:12.39Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/b0/41/8e6b6ef7e225d4ceead8459427a52afdc23379768f54dd3566014d7618c1/pyarrow-23.0.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:6f0147ee9e0386f519c952cc670eb4a8b05caa594eeffe01af0e25f699e4e9bb", size = 34302230, upload-time = "2026-02-16T10:09:03.859Z" },+ { url = "https://files.pythonhosted.org/packages/bf/4a/1472c00392f521fea03ae93408bf445cc7bfa1ab81683faf9bc188e36629/pyarrow-23.0.1-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:0ae6e17c828455b6265d590100c295193f93cc5675eb0af59e49dbd00d2de350", size = 35850050, upload-time = "2026-02-16T10:09:11.877Z" },+ { url = "https://files.pythonhosted.org/packages/0c/b2/bd1f2f05ded56af7f54d702c8364c9c43cd6abb91b0e9933f3d77b4f4132/pyarrow-23.0.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:fed7020203e9ef273360b9e45be52a2a47d3103caf156a30ace5247ffb51bdbd", size = 44491918, upload-time = "2026-02-16T10:09:18.144Z" },+ { url = "https://files.pythonhosted.org/packages/0b/62/96459ef5b67957eac38a90f541d1c28833d1b367f014a482cb63f3b7cd2d/pyarrow-23.0.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:26d50dee49d741ac0e82185033488d28d35be4d763ae6f321f97d1140eb7a0e9", size = 47562811, upload-time = "2026-02-16T10:09:25.792Z" },+ { url = "https://files.pythonhosted.org/packages/7d/94/1170e235add1f5f45a954e26cd0e906e7e74e23392dcb560de471f7366ec/pyarrow-23.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3c30143b17161310f151f4a2bcfe41b5ff744238c1039338779424e38579d701", size = 48183766, upload-time = "2026-02-16T10:09:34.645Z" },+ { url = "https://files.pythonhosted.org/packages/0e/2d/39a42af4570377b99774cdb47f63ee6c7da7616bd55b3d5001aa18edfe4f/pyarrow-23.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db2190fa79c80a23fdd29fef4b8992893f024ae7c17d2f5f4db7171fa30c2c78", size = 50607669, upload-time = "2026-02-16T10:09:44.153Z" },+ { url = "https://files.pythonhosted.org/packages/00/ca/db94101c187f3df742133ac837e93b1f269ebdac49427f8310ee40b6a58f/pyarrow-23.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:f00f993a8179e0e1c9713bcc0baf6d6c01326a406a9c23495ec1ba9c9ebf2919", size = 27527698, upload-time = "2026-02-16T10:09:50.263Z" },+ { url = "https://files.pythonhosted.org/packages/9a/4b/4166bb5abbfe6f750fc60ad337c43ecf61340fa52ab386da6e8dbf9e63c4/pyarrow-23.0.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:f4b0dbfa124c0bb161f8b5ebb40f1a680b70279aa0c9901d44a2b5a20806039f", size = 34214575, upload-time = "2026-02-16T10:09:56.225Z" },+ { url = "https://files.pythonhosted.org/packages/e1/da/3f941e3734ac8088ea588b53e860baeddac8323ea40ce22e3d0baa865cc9/pyarrow-23.0.1-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:7707d2b6673f7de054e2e83d59f9e805939038eebe1763fe811ee8fa5c0cd1a7", size = 35832540, upload-time = "2026-02-16T10:10:03.428Z" },+ { url = "https://files.pythonhosted.org/packages/88/7c/3d841c366620e906d54430817531b877ba646310296df42ef697308c2705/pyarrow-23.0.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:86ff03fb9f1a320266e0de855dee4b17da6794c595d207f89bba40d16b5c78b9", size = 44470940, upload-time = "2026-02-16T10:10:10.704Z" },+ { url = "https://files.pythonhosted.org/packages/2c/a5/da83046273d990f256cb79796a190bbf7ec999269705ddc609403f8c6b06/pyarrow-23.0.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:813d99f31275919c383aab17f0f455a04f5a429c261cc411b1e9a8f5e4aaaa05", size = 47586063, upload-time = "2026-02-16T10:10:17.95Z" },+ { url = "https://files.pythonhosted.org/packages/5b/3c/b7d2ebcff47a514f47f9da1e74b7949138c58cfeb108cdd4ee62f43f0cf3/pyarrow-23.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bf5842f960cddd2ef757d486041d57c96483efc295a8c4a0e20e704cbbf39c67", size = 48173045, upload-time = "2026-02-16T10:10:25.363Z" },+ { url = "https://files.pythonhosted.org/packages/43/b2/b40961262213beaba6acfc88698eb773dfce32ecdf34d19291db94c2bd73/pyarrow-23.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:564baf97c858ecc03ec01a41062e8f4698abc3e6e2acd79c01c2e97880a19730", size = 50621741, upload-time = "2026-02-16T10:10:33.477Z" },+ { url = "https://files.pythonhosted.org/packages/f6/70/1fdda42d65b28b078e93d75d371b2185a61da89dda4def8ba6ba41ebdeb4/pyarrow-23.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:07deae7783782ac7250989a7b2ecde9b3c343a643f82e8a4df03d93b633006f0", size = 27620678, upload-time = "2026-02-16T10:10:39.31Z" },+ { url = "https://files.pythonhosted.org/packages/47/10/2cbe4c6f0fb83d2de37249567373d64327a5e4d8db72f486db42875b08f6/pyarrow-23.0.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:6b8fda694640b00e8af3c824f99f789e836720aa8c9379fb435d4c4953a756b8", size = 34210066, upload-time = "2026-02-16T10:10:45.487Z" },+ { url = "https://files.pythonhosted.org/packages/cb/4f/679fa7e84dadbaca7a65f7cdba8d6c83febbd93ca12fa4adf40ba3b6362b/pyarrow-23.0.1-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:8ff51b1addc469b9444b7c6f3548e19dc931b172ab234e995a60aea9f6e6025f", size = 35825526, upload-time = "2026-02-16T10:10:52.266Z" },+ { url = "https://files.pythonhosted.org/packages/f9/63/d2747d930882c9d661e9398eefc54f15696547b8983aaaf11d4a2e8b5426/pyarrow-23.0.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:71c5be5cbf1e1cb6169d2a0980850bccb558ddc9b747b6206435313c47c37677", size = 44473279, upload-time = "2026-02-16T10:11:01.557Z" },+ { url = "https://files.pythonhosted.org/packages/b3/93/10a48b5e238de6d562a411af6467e71e7aedbc9b87f8d3a35f1560ae30fb/pyarrow-23.0.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:9b6f4f17b43bc39d56fec96e53fe89d94bac3eb134137964371b45352d40d0c2", size = 47585798, upload-time = "2026-02-16T10:11:09.401Z" },+ { url = "https://files.pythonhosted.org/packages/5c/20/476943001c54ef078dbf9542280e22741219a184a0632862bca4feccd666/pyarrow-23.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9fc13fc6c403d1337acab46a2c4346ca6c9dec5780c3c697cf8abfd5e19b6b37", size = 48179446, upload-time = "2026-02-16T10:11:17.781Z" },+ { url = "https://files.pythonhosted.org/packages/4b/b6/5dd0c47b335fcd8edba9bfab78ad961bd0fd55ebe53468cc393f45e0be60/pyarrow-23.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5c16ed4f53247fa3ffb12a14d236de4213a4415d127fe9cebed33d51671113e2", size = 50623972, upload-time = "2026-02-16T10:11:26.185Z" },+ { url = "https://files.pythonhosted.org/packages/d5/09/a532297c9591a727d67760e2e756b83905dd89adb365a7f6e9c72578bcc1/pyarrow-23.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:cecfb12ef629cf6be0b1887f9f86463b0dd3dc3195ae6224e74006be4736035a", size = 27540749, upload-time = "2026-02-16T10:12:23.297Z" },+ { url = "https://files.pythonhosted.org/packages/a5/8e/38749c4b1303e6ae76b3c80618f84861ae0c55dd3c2273842ea6f8258233/pyarrow-23.0.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:29f7f7419a0e30264ea261fdc0e5fe63ce5a6095003db2945d7cd78df391a7e1", size = 34471544, upload-time = "2026-02-16T10:11:32.535Z" },+ { url = "https://files.pythonhosted.org/packages/a3/73/f237b2bc8c669212f842bcfd842b04fc8d936bfc9d471630569132dc920d/pyarrow-23.0.1-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:33d648dc25b51fd8055c19e4261e813dfc4d2427f068bcecc8b53d01b81b0500", size = 35949911, upload-time = "2026-02-16T10:11:39.813Z" },+ { url = "https://files.pythonhosted.org/packages/0c/86/b912195eee0903b5611bf596833def7d146ab2d301afeb4b722c57ffc966/pyarrow-23.0.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:cd395abf8f91c673dd3589cadc8cc1ee4e8674fa61b2e923c8dd215d9c7d1f41", size = 44520337, upload-time = "2026-02-16T10:11:47.764Z" },+ { url = "https://files.pythonhosted.org/packages/69/c2/f2a717fb824f62d0be952ea724b4f6f9372a17eed6f704b5c9526f12f2f1/pyarrow-23.0.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:00be9576d970c31defb5c32eb72ef585bf600ef6d0a82d5eccaae96639cf9d07", size = 47548944, upload-time = "2026-02-16T10:11:56.607Z" },+ { url = "https://files.pythonhosted.org/packages/84/a7/90007d476b9f0dc308e3bc57b832d004f848fd6c0da601375d20d92d1519/pyarrow-23.0.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c2139549494445609f35a5cda4eb94e2c9e4d704ce60a095b342f82460c73a83", size = 48236269, upload-time = "2026-02-16T10:12:04.47Z" },+ { url = "https://files.pythonhosted.org/packages/b0/3f/b16fab3e77709856eb6ac328ce35f57a6d4a18462c7ca5186ef31b45e0e0/pyarrow-23.0.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7044b442f184d84e2351e5084600f0d7343d6117aabcbc1ac78eb1ae11eb4125", size = 50604794, upload-time = "2026-02-16T10:12:11.797Z" },+ { url = "https://files.pythonhosted.org/packages/e9/a1/22df0620a9fac31d68397a75465c344e83c3dfe521f7612aea33e27ab6c0/pyarrow-23.0.1-cp313-cp313t-win_amd64.whl", hash = "sha256:a35581e856a2fafa12f3f54fce4331862b1cfb0bef5758347a858a4aa9d6bae8", size = 27660642, upload-time = "2026-02-16T10:12:17.746Z" },+ { url = "https://files.pythonhosted.org/packages/8d/1b/6da9a89583ce7b23ac611f183ae4843cd3a6cf54f079549b0e8c14031e73/pyarrow-23.0.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:5df1161da23636a70838099d4aaa65142777185cc0cdba4037a18cee7d8db9ca", size = 34238755, upload-time = "2026-02-16T10:12:32.819Z" },+ { url = "https://files.pythonhosted.org/packages/ae/b5/d58a241fbe324dbaeb8df07be6af8752c846192d78d2272e551098f74e88/pyarrow-23.0.1-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:fa8e51cb04b9f8c9c5ace6bab63af9a1f88d35c0d6cbf53e8c17c098552285e1", size = 35847826, upload-time = "2026-02-16T10:12:38.949Z" },+ { url = "https://files.pythonhosted.org/packages/54/a5/8cbc83f04aba433ca7b331b38f39e000efd9f0c7ce47128670e737542996/pyarrow-23.0.1-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:0b95a3994f015be13c63148fef8832e8a23938128c185ee951c98908a696e0eb", size = 44536859, upload-time = "2026-02-16T10:12:45.467Z" },+ { url = "https://files.pythonhosted.org/packages/36/2e/c0f017c405fcdc252dbccafbe05e36b0d0eb1ea9a958f081e01c6972927f/pyarrow-23.0.1-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:4982d71350b1a6e5cfe1af742c53dfb759b11ce14141870d05d9e540d13bc5d1", size = 47614443, upload-time = "2026-02-16T10:12:55.525Z" },+ { url = "https://files.pythonhosted.org/packages/af/6b/2314a78057912f5627afa13ba43809d9d653e6630859618b0fd81a4e0759/pyarrow-23.0.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c250248f1fe266db627921c89b47b7c06fee0489ad95b04d50353537d74d6886", size = 48232991, upload-time = "2026-02-16T10:13:04.729Z" },+ { url = "https://files.pythonhosted.org/packages/40/f2/1bcb1d3be3460832ef3370d621142216e15a2c7c62602a4ea19ec240dd64/pyarrow-23.0.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5f4763b83c11c16e5f4c15601ba6dfa849e20723b46aa2617cb4bffe8768479f", size = 50645077, upload-time = "2026-02-16T10:13:14.147Z" },+ { url = "https://files.pythonhosted.org/packages/eb/3f/b1da7b61cd66566a4d4c8383d376c606d1c34a906c3f1cb35c479f59d1aa/pyarrow-23.0.1-cp314-cp314-win_amd64.whl", hash = "sha256:3a4c85ef66c134161987c17b147d6bffdca4566f9a4c1d81a0a01cdf08414ea5", size = 28234271, upload-time = "2026-02-16T10:14:09.397Z" },+ { url = "https://files.pythonhosted.org/packages/b5/78/07f67434e910a0f7323269be7bfbf58699bd0c1d080b18a1ab49ba943fe8/pyarrow-23.0.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:17cd28e906c18af486a499422740298c52d7c6795344ea5002a7720b4eadf16d", size = 34488692, upload-time = "2026-02-16T10:13:21.541Z" },+ { url = "https://files.pythonhosted.org/packages/50/76/34cf7ae93ece1f740a04910d9f7e80ba166b9b4ab9596a953e9e62b90fe1/pyarrow-23.0.1-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:76e823d0e86b4fb5e1cf4a58d293036e678b5a4b03539be933d3b31f9406859f", size = 35964383, upload-time = "2026-02-16T10:13:28.63Z" },+ { url = "https://files.pythonhosted.org/packages/46/90/459b827238936d4244214be7c684e1b366a63f8c78c380807ae25ed92199/pyarrow-23.0.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:a62e1899e3078bf65943078b3ad2a6ddcacf2373bc06379aac61b1e548a75814", size = 44538119, upload-time = "2026-02-16T10:13:35.506Z" },+ { url = "https://files.pythonhosted.org/packages/28/a1/93a71ae5881e99d1f9de1d4554a87be37da11cd6b152239fb5bd924fdc64/pyarrow-23.0.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:df088e8f640c9fae3b1f495b3c64755c4e719091caf250f3a74d095ddf3c836d", size = 47571199, upload-time = "2026-02-16T10:13:42.504Z" },+ { url = "https://files.pythonhosted.org/packages/88/a3/d2c462d4ef313521eaf2eff04d204ac60775263f1fb08c374b543f79f610/pyarrow-23.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:46718a220d64677c93bc243af1d44b55998255427588e400677d7192671845c7", size = 48259435, upload-time = "2026-02-16T10:13:49.226Z" },+ { url = "https://files.pythonhosted.org/packages/cc/f1/11a544b8c3d38a759eb3fbb022039117fd633e9a7b19e4841cc3da091915/pyarrow-23.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a09f3876e87f48bc2f13583ab551f0379e5dfb83210391e68ace404181a20690", size = 50629149, upload-time = "2026-02-16T10:13:57.238Z" },+ { url = "https://files.pythonhosted.org/packages/50/f2/c0e76a0b451ffdf0cf788932e182758eb7558953f4f27f1aff8e2518b653/pyarrow-23.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:527e8d899f14bd15b740cd5a54ad56b7f98044955373a17179d5956ddb93d9ce", size = 28365807, upload-time = "2026-02-16T10:14:03.892Z" },][[package]]@@ -1368,32 +1313,32 @@ dependencies = [{ name = "numpy" },]wheels = [- { url = "https://files.pythonhosted.org/packages/f9/a3/9519766129c8876f158ec4a8b8d65d1ae9ec03ac97c5cdd621b34d4f0331/pyceres-2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:078ee92e6e9d98a20c030b52396248c41499ed5159342a9163cdfc2ab40e49c0", size = 2414855 },- { url = "https://files.pythonhosted.org/packages/95/83/53617e96fca87bf01b8d27f9ab51b03c7ff5828cbed1102952c69b4eafbc/pyceres-2.6-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:294b16310be0f3024eb1c592d8df86bbb227b1443008a51cf01c47ac7c9d3eb2", size = 4931387 },- { url = "https://files.pythonhosted.org/packages/ab/07/f4fb0fb6fa43a986cae009b3dae5ad6e5929786d7528dbdf92429e83c46f/pyceres-2.6-cp311-cp311-win_amd64.whl", hash = "sha256:66e8b8a69c926a01ae59f7aabf3812b1d8496434e22e064b23006335f3913084", size = 8454404 },- { url = "https://files.pythonhosted.org/packages/b4/a7/bc1aaea0a2e06b35f1b856c95e0a392719d1395488e36ff87066dba09cc4/pyceres-2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:8ef9014f84b31dbf94936f11964411f67e9cc1733aca8ff38fda079b890adfa7", size = 2420210 },- { url = "https://files.pythonhosted.org/packages/dc/6d/bea6219072d8d86a5f11f6f61c588780be0bbd5aca1221fc8ad646bcba73/pyceres-2.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:284204c5303c582dc3918f43288e7b78bfc674a01e5561b252298a2d133ad14d", size = 4933829 },- { url = "https://files.pythonhosted.org/packages/4c/4c/2291a63a81ddfa306ee18d57156a458758953933212f224ea3a7bb6b036c/pyceres-2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c7e24463365778f423c34cd0e06ce57634a2e26da16935eec094c72263520493", size = 8457845 },- { url = "https://files.pythonhosted.org/packages/7a/6d/9e55d8f6b1c504b2a5ac8220aa979e4d2c209be680a67cccb8e729cca34e/pyceres-2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:8561fe1e520171499a606ca500baa5d3f90012dd264e9696fdd87126bed9378d", size = 2420311 },- { url = "https://files.pythonhosted.org/packages/49/9a/17e371fbcbe29f1041a7014630bb7ff03c87215240b14362fe7e57bdef40/pyceres-2.6-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f5a408a205a690431190b21a4448130c67b838b14dfd459cee22361a06060a1f", size = 4933511 },- { url = "https://files.pythonhosted.org/packages/1f/32/7588f22cc526abdef03414648eb7bedff5bd5353627f5646f988c2129687/pyceres-2.6-cp313-cp313-win_amd64.whl", hash = "sha256:c8da59494f317f38d8f7c3e980052997f4d5b01d456e440d964a38d09a26bdea", size = 8457867 },- { url = "https://files.pythonhosted.org/packages/63/89/eaf73a99c4999452e1bb8c9369e477567abc58ff8ece636d20522683157b/pyceres-2.6-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:8759bfe308e2f951a7e1f0752b345856dc276300336bddaea9d35dd86f6d8c16", size = 2422877 },- { url = "https://files.pythonhosted.org/packages/f7/08/25c45688d04b1a474ffba4726f219947afd36e02d925bc3387b4a9073bc1/pyceres-2.6-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0932b7cb21de92823bbc48c7bbb8c8df992c8a43498b99b64ee37293269ef3d0", size = 4934918 },- { url = "https://files.pythonhosted.org/packages/f4/78/75487ad67101a0c1f2f727fa11020329a43a2ab628f85abbe59937c49c5b/pyceres-2.6-cp314-cp314-win_amd64.whl", hash = "sha256:e89d4d4d6c3507058a751c72b4dd4c59f6742a0a4262845b1ceafff65f943a2c", size = 8634720 },+ { url = "https://files.pythonhosted.org/packages/f9/a3/9519766129c8876f158ec4a8b8d65d1ae9ec03ac97c5cdd621b34d4f0331/pyceres-2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:078ee92e6e9d98a20c030b52396248c41499ed5159342a9163cdfc2ab40e49c0", size = 2414855, upload-time = "2025-11-05T12:35:59.668Z" },+ { url = "https://files.pythonhosted.org/packages/95/83/53617e96fca87bf01b8d27f9ab51b03c7ff5828cbed1102952c69b4eafbc/pyceres-2.6-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:294b16310be0f3024eb1c592d8df86bbb227b1443008a51cf01c47ac7c9d3eb2", size = 4931387, upload-time = "2025-11-05T12:36:02.389Z" },+ { url = "https://files.pythonhosted.org/packages/ab/07/f4fb0fb6fa43a986cae009b3dae5ad6e5929786d7528dbdf92429e83c46f/pyceres-2.6-cp311-cp311-win_amd64.whl", hash = "sha256:66e8b8a69c926a01ae59f7aabf3812b1d8496434e22e064b23006335f3913084", size = 8454404, upload-time = "2025-11-05T12:36:04.361Z" },+ { url = "https://files.pythonhosted.org/packages/b4/a7/bc1aaea0a2e06b35f1b856c95e0a392719d1395488e36ff87066dba09cc4/pyceres-2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:8ef9014f84b31dbf94936f11964411f67e9cc1733aca8ff38fda079b890adfa7", size = 2420210, upload-time = "2025-11-05T12:36:06.482Z" },+ { url = "https://files.pythonhosted.org/packages/dc/6d/bea6219072d8d86a5f11f6f61c588780be0bbd5aca1221fc8ad646bcba73/pyceres-2.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:284204c5303c582dc3918f43288e7b78bfc674a01e5561b252298a2d133ad14d", size = 4933829, upload-time = "2025-11-05T12:36:08.241Z" },+ { url = "https://files.pythonhosted.org/packages/4c/4c/2291a63a81ddfa306ee18d57156a458758953933212f224ea3a7bb6b036c/pyceres-2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c7e24463365778f423c34cd0e06ce57634a2e26da16935eec094c72263520493", size = 8457845, upload-time = "2025-11-05T12:36:09.956Z" },+ { url = "https://files.pythonhosted.org/packages/7a/6d/9e55d8f6b1c504b2a5ac8220aa979e4d2c209be680a67cccb8e729cca34e/pyceres-2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:8561fe1e520171499a606ca500baa5d3f90012dd264e9696fdd87126bed9378d", size = 2420311, upload-time = "2025-11-05T12:36:12.29Z" },+ { url = "https://files.pythonhosted.org/packages/49/9a/17e371fbcbe29f1041a7014630bb7ff03c87215240b14362fe7e57bdef40/pyceres-2.6-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f5a408a205a690431190b21a4448130c67b838b14dfd459cee22361a06060a1f", size = 4933511, upload-time = "2025-11-05T12:36:14.367Z" },+ { url = "https://files.pythonhosted.org/packages/1f/32/7588f22cc526abdef03414648eb7bedff5bd5353627f5646f988c2129687/pyceres-2.6-cp313-cp313-win_amd64.whl", hash = "sha256:c8da59494f317f38d8f7c3e980052997f4d5b01d456e440d964a38d09a26bdea", size = 8457867, upload-time = "2025-11-05T12:36:16.084Z" },+ { url = "https://files.pythonhosted.org/packages/63/89/eaf73a99c4999452e1bb8c9369e477567abc58ff8ece636d20522683157b/pyceres-2.6-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:8759bfe308e2f951a7e1f0752b345856dc276300336bddaea9d35dd86f6d8c16", size = 2422877, upload-time = "2025-11-05T12:36:18.414Z" },+ { url = "https://files.pythonhosted.org/packages/f7/08/25c45688d04b1a474ffba4726f219947afd36e02d925bc3387b4a9073bc1/pyceres-2.6-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0932b7cb21de92823bbc48c7bbb8c8df992c8a43498b99b64ee37293269ef3d0", size = 4934918, upload-time = "2025-11-05T12:36:20.582Z" },+ { url = "https://files.pythonhosted.org/packages/f4/78/75487ad67101a0c1f2f727fa11020329a43a2ab628f85abbe59937c49c5b/pyceres-2.6-cp314-cp314-win_amd64.whl", hash = "sha256:e89d4d4d6c3507058a751c72b4dd4c59f6742a0a4262845b1ceafff65f943a2c", size = 8634720, upload-time = "2025-11-05T12:36:22.282Z" },][[package]]name = "pycparser"-version = "2.23"+version = "3.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734 }+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140 },+ { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },][[package]]name = "pydantic"-version = "2.12.4"+version = "2.12.5"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "annotated-types" },@@ -1401,9 +1346,9 @@ dependencies = [{ name = "typing-extensions" },{ name = "typing-inspection" },]-sdist = { url = "https://files.pythonhosted.org/packages/96/ad/a17bc283d7d81837c061c49e3eaa27a45991759a1b7eae1031921c6bd924/pydantic-2.12.4.tar.gz", hash = "sha256:0f8cb9555000a4b5b617f66bfd2566264c4984b27589d3b845685983e8ea85ac", size = 821038 }+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/82/2f/e68750da9b04856e2a7ec56fc6f034a5a79775e9b9a81882252789873798/pydantic-2.12.4-py3-none-any.whl", hash = "sha256:92d3d202a745d46f9be6df459ac5a064fdaa3c1c4cd8adcfa332ccf3c05f871e", size = 463400 },+ { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },][[package]]@@ -1413,108 +1358,108 @@ source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "typing-extensions" },]-sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952 }-wheels = [- { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873 },- { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826 },- { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869 },- { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890 },- { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740 },- { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021 },- { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378 },- { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761 },- { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303 },- { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355 },- { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875 },- { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549 },- { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305 },- { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902 },- { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990 },- { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003 },- { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200 },- { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578 },- { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504 },- { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816 },- { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366 },- { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698 },- { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603 },- { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591 },- { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068 },- { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908 },- { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145 },- { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179 },- { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403 },- { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206 },- { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307 },- { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258 },- { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917 },- { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186 },- { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164 },- { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146 },- { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788 },- { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133 },- { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852 },- { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679 },- { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766 },- { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005 },- { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622 },- { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725 },- { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040 },- { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691 },- { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897 },- { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302 },- { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877 },- { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680 },- { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960 },- { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102 },- { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039 },- { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126 },- { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489 },- { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288 },- { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255 },- { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760 },- { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092 },- { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385 },- { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832 },- { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585 },- { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078 },- { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914 },- { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560 },- { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244 },- { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955 },- { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906 },- { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607 },- { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769 },- { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441 },- { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291 },- { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632 },- { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905 },- { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495 },- { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388 },- { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879 },- { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017 },- { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980 },- { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865 },- { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256 },- { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762 },- { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141 },- { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317 },- { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992 },- { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302 },+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" },+ { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" },+ { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" },+ { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" },+ { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" },+ { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" },+ { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" },+ { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" },+ { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" },+ { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" },+ { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" },+ { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" },+ { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" },+ { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" },+ { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },+ { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },+ { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },+ { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },+ { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },+ { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },+ { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },+ { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },+ { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },+ { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },+ { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },+ { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },+ { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },+ { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },+ { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },+ { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },+ { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },+ { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },+ { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },+ { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },+ { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },+ { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },+ { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },+ { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },+ { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },+ { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },+ { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },+ { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },+ { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },+ { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },+ { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },+ { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },+ { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },+ { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },+ { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },+ { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },+ { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },+ { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },+ { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },+ { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },+ { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },+ { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },+ { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },+ { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },+ { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },+ { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },+ { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },+ { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },+ { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },+ { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },+ { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },+ { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },+ { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },+ { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },+ { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },+ { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },+ { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" },+ { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" },+ { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" },+ { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" },+ { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },+ { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },+ { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },+ { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },+ { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" },+ { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" },+ { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" },+ { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" },+ { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" },+ { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" },+ { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" },+ { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },][[package]]name = "pygments"version = "2.19.2"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631 }+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217 },+ { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },][[package]]name = "pyinstaller"-version = "6.16.0"+version = "6.19.0"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "altgraph" },@@ -1525,211 +1470,219 @@ dependencies = [{ name = "pywin32-ctypes", marker = "sys_platform == 'win32'" },{ name = "setuptools" },]-sdist = { url = "https://files.pythonhosted.org/packages/94/94/1f62e95e4a28b64cfbb5b922ef3046f968b47170d37a1e1a029f56ac9cb4/pyinstaller-6.16.0.tar.gz", hash = "sha256:53559fe1e041a234f2b4dcc3288ea8bdd57f7cad8a6644e422c27bb407f3edef", size = 4008473 }+sdist = { url = "https://files.pythonhosted.org/packages/c8/63/fd62472b6371d89dc138d40c36d87a50dc2de18a035803bbdc376b4ffac4/pyinstaller-6.19.0.tar.gz", hash = "sha256:ec73aeb8bd9b7f2f1240d328a4542e90b3c6e6fbc106014778431c616592a865", size = 4036072, upload-time = "2026-02-14T18:06:28.718Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/7b/0a/c42ce6e5d3de287f2e9432a074fb209f1fb72a86a72f3903849fdb5e4829/pyinstaller-6.16.0-py3-none-macosx_10_13_universal2.whl", hash = "sha256:7fd1c785219a87ca747c21fa92f561b0d2926a7edc06d0a0fe37f3736e00bd7a", size = 1027899 },- { url = "https://files.pythonhosted.org/packages/4e/d0/f18fedde32835d5a758f464c75924e2154065625f09d5456c3c303527654/pyinstaller-6.16.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:b756ddb9007b8141c5476b553351f9d97559b8af5d07f9460869bfae02be26b0", size = 727990 },- { url = "https://files.pythonhosted.org/packages/7a/db/c8bb47514ce857b24bf9294cf1ff74844b6a489fa0ab4ef6f923288c4e38/pyinstaller-6.16.0-py3-none-manylinux2014_i686.whl", hash = "sha256:0a48f55b85ff60f83169e10050f2759019cf1d06773ad1c4da3a411cd8751058", size = 739238 },- { url = "https://files.pythonhosted.org/packages/c6/3e/451dc784a8fcca0fe9f9b6b802d58555364a95b60f253613a2c83fc6b023/pyinstaller-6.16.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:73ba72e04fcece92e32518bbb1e1fb5ac2892677943dfdff38e01a06e8742851", size = 737142 },- { url = "https://files.pythonhosted.org/packages/71/37/2f457479ef8fa2821cdb448acee2421dfb19fbe908bf5499d1930c164084/pyinstaller-6.16.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:b1752488248f7899281b17ca3238eefb5410521291371a686a4f5830f29f52b3", size = 734133 },- { url = "https://files.pythonhosted.org/packages/63/c4/0f7daac4d062a4d1ac2571d8a8b9b5d6812094fcd914d139af591ca5e1ba/pyinstaller-6.16.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:ba618a61627ee674d6d68e5de084ba17c707b59a4f2a856084b3999bdffbd3f0", size = 733817 },- { url = "https://files.pythonhosted.org/packages/11/e4/b6127265b42bef883e8873d850becadf748bc5652e5a7029b059328f3c31/pyinstaller-6.16.0-py3-none-musllinux_1_1_aarch64.whl", hash = "sha256:c8b7ef536711617e12fef4673806198872033fa06fa92326ad7fd1d84a9fa454", size = 732912 },- { url = "https://files.pythonhosted.org/packages/2b/00/c6663107bdf814b2916e71563beabd09f693c47712213bc228994cb2cc65/pyinstaller-6.16.0-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:d1ebf84d02c51fed19b82a8abb4df536923abd55bb684d694e1356e4ae2a0ce5", size = 732773 },- { url = "https://files.pythonhosted.org/packages/a3/14/cabe9bc5f60b95d2e70e7d045ab94b0015ff8f6c8b16e2142d3597e30749/pyinstaller-6.16.0-py3-none-win32.whl", hash = "sha256:6d5f8617f3650ff9ef893e2ab4ddbf3c0d23d0c602ef74b5df8fbef4607840c8", size = 1313878 },- { url = "https://files.pythonhosted.org/packages/aa/99/2005efbc297e7813c1d6f18484aa94a1a81ce87b6a5b497c563681f4c4ea/pyinstaller-6.16.0-py3-none-win_amd64.whl", hash = "sha256:bc10eb1a787f99fea613509f55b902fbd2d8b73ff5f51ff245ea29a481d97d41", size = 1374706 },- { url = "https://files.pythonhosted.org/packages/ca/f4/4dfcf69b86d60fcaae05a42bbff1616d48a91e71726e5ed795d773dae9b3/pyinstaller-6.16.0-py3-none-win_arm64.whl", hash = "sha256:d0af8a401de792c233c32c44b16d065ca9ab8262ee0c906835c12bdebc992a64", size = 1315923 },+ { url = "https://files.pythonhosted.org/packages/e3/eb/23374721fecfa72677e79800921cb6aceefa6ba48574dc404f3f6c6c3be7/pyinstaller-6.19.0-py3-none-macosx_10_13_universal2.whl", hash = "sha256:4190e76b74f0c4b5c5f11ac360928cd2e36ec8e3194d437bf6b8648c7bc0c134", size = 1040563, upload-time = "2026-02-14T18:05:22.436Z" },+ { url = "https://files.pythonhosted.org/packages/cd/7e/dfd724b0b533f5aaec0ee5df406fe2319987ed6964480a706f85478b12ea/pyinstaller-6.19.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:8bd68abd812d8a6ba33b9f1810e91fee0f325969733721b78151f0065319ca11", size = 735477, upload-time = "2026-02-14T18:05:27.143Z" },+ { url = "https://files.pythonhosted.org/packages/88/c9/ee3a4101c31f26344e66896c73c1fd6ed8282bf871473365b7f8674af406/pyinstaller-6.19.0-py3-none-manylinux2014_i686.whl", hash = "sha256:1ec54ef967996ca61dacba676227e2b23219878ccce5ee9d6f3aada7b8ed8abf", size = 747143, upload-time = "2026-02-14T18:05:31.488Z" },+ { url = "https://files.pythonhosted.org/packages/da/0a/fc77e9f861be8cf300ac37155f59cc92aff99b29f2ddd78546f563a5b5a6/pyinstaller-6.19.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:4ab2bb52e58448e14ddf9450601bdedd66800465043501c1d8f1cab87b60b122", size = 744849, upload-time = "2026-02-14T18:05:35.492Z" },+ { url = "https://files.pythonhosted.org/packages/6d/e3/6872e020ee758afe0b821663858492c10745608b07150e5e2c824a5b3e1c/pyinstaller-6.19.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:da6d5c6391ccefe73554b9fa29b86001c8e378e0f20c2a4004f836ba537eff63", size = 741590, upload-time = "2026-02-14T18:05:39.59Z" },+ { url = "https://files.pythonhosted.org/packages/53/60/b8db5f1a4b0fb228175f2ea0aa33f949adcc097fbe981cc524f9faf85777/pyinstaller-6.19.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a0fc5f6b3c55aa54353f0c74ffa59b1115433c1850c6f655d62b461a2ed6cbbe", size = 741448, upload-time = "2026-02-14T18:05:45.636Z" },+ { url = "https://files.pythonhosted.org/packages/6f/4d/63b0600f2694e9141b83129fbc1c488ec84d5a0770b1448ec154dcd0fee9/pyinstaller-6.19.0-py3-none-musllinux_1_1_aarch64.whl", hash = "sha256:e649ba6bd1b0b89b210ad92adb5fbdc8a42dd2c5ca4f72ef3a0bfec83a424b83", size = 740613, upload-time = "2026-02-14T18:05:49.726Z" },+ { url = "https://files.pythonhosted.org/packages/01/d4/e812ad36178093a0e9fd4b8127577748dd85b0cb71de912229dca21fd741/pyinstaller-6.19.0-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:481a909c8e60c8692fc60fcb1344d984b44b943f8bc9682f2fcdae305ad297e6", size = 740350, upload-time = "2026-02-14T18:05:54.093Z" },+ { url = "https://files.pythonhosted.org/packages/52/03/b2c2ee41fb8e10fd2a45d21f5ec2ef25852cfb978dbf762972eed59e3d63/pyinstaller-6.19.0-py3-none-win32.whl", hash = "sha256:3c5c251054fe4cfaa04c34a363dcfbf811545438cb7198304cd444756bc2edd2", size = 1324317, upload-time = "2026-02-14T18:06:00.085Z" },+ { url = "https://files.pythonhosted.org/packages/9c/d3/6d5e62b8270e2b53a6065e281b3a7785079b00e9019c8019952828dd1669/pyinstaller-6.19.0-py3-none-win_amd64.whl", hash = "sha256:b5bb6536c6560330d364d91522250f254b107cf69129d9cbcd0e6727c570be33", size = 1384894, upload-time = "2026-02-14T18:06:06.425Z" },+ { url = "https://files.pythonhosted.org/packages/81/65/458cd523308a101a22fd2742893405030cc24994cc74b1b767cecf137160/pyinstaller-6.19.0-py3-none-win_arm64.whl", hash = "sha256:c2d5a539b0bfe6159d5522c8c70e1c0e487f22c2badae0f97d45246223b798ea", size = 1325374, upload-time = "2026-02-14T18:06:12.804Z" },][[package]]name = "pyinstaller-hooks-contrib"-version = "2025.9"+version = "2026.1"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "packaging" },{ name = "setuptools" },]-sdist = { url = "https://files.pythonhosted.org/packages/7d/83/be0f57c0b77b66c33c2283ebd4ea341022b5a743e97c5fb3bebab82b38b9/pyinstaller_hooks_contrib-2025.9.tar.gz", hash = "sha256:56e972bdaad4e9af767ed47d132362d162112260cbe488c9da7fee01f228a5a6", size = 165189 }+sdist = { url = "https://files.pythonhosted.org/packages/95/eb/e1dd9a5348e4cf348471c0e5fd617d948779bc3199cf4edb134d8fceca91/pyinstaller_hooks_contrib-2026.1.tar.gz", hash = "sha256:a5f0891a1e81e92406ab917d9e76adfd7a2b68415ee2e35c950a7b3910bc361b", size = 171504, upload-time = "2026-02-18T13:01:15.711Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/a2/26/23b4cfc77d7f808c69f59070e1e8293a579ec281a547c61562357160b346/pyinstaller_hooks_contrib-2025.9-py3-none-any.whl", hash = "sha256:ccbfaa49399ef6b18486a165810155e5a8d4c59b41f20dc5da81af7482aaf038", size = 444283 },+ { url = "https://files.pythonhosted.org/packages/7f/69/12bafee3cc485d977f596e0d803d7c6fb147430fc35dfe505730aa3a28dd/pyinstaller_hooks_contrib-2026.1-py3-none-any.whl", hash = "sha256:66ad4888ba67de6f3cfd7ef554f9dd1a4389e2eb19f84d7129a5a6818e3f2180", size = 452841, upload-time = "2026-02-18T13:01:14.471Z" },][[package]]name = "pyobjc-core"-version = "12.0"+version = "12.1"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/ab/dc/6d63019133e39e2b299dfbab786e64997fff0f145c45a417e1dd51faaf3f/pyobjc_core-12.0.tar.gz", hash = "sha256:7e05c805a776149a937b61b892a0459895d32d9002bedc95ce2be31ef1e37a29", size = 991669 }+sdist = { url = "https://files.pythonhosted.org/packages/b8/b6/d5612eb40be4fd5ef88c259339e6313f46ba67577a95d86c3470b951fce0/pyobjc_core-12.1.tar.gz", hash = "sha256:2bb3903f5387f72422145e1466b3ac3f7f0ef2e9960afa9bcd8961c5cbf8bd21", size = 1000532, upload-time = "2025-11-14T10:08:28.292Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/84/c1/c50e312d32644429d8a9bb3a342aeeb772fba85f9573e7681ca458124a8f/pyobjc_core-12.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:dd4962aceb0f9a0ee510e11ced449323db85e42664ac9ade53ad1cc2394dc248", size = 673921 },- { url = "https://files.pythonhosted.org/packages/38/95/1acf3be6a8ae457a26e8ff6e08aeb71af49bfc79303b331067c058d448a4/pyobjc_core-12.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1675dbb700b6bb6e3f3c9ce3f5401947e0193e16085eeb70e9160c6c6fc1ace5", size = 681179 },- { url = "https://files.pythonhosted.org/packages/88/17/6c247bf9d8de2813f6015671f242333534797e81bdac9e85516fb57dfb00/pyobjc_core-12.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c44b76d8306a130c9eb0cb79d86fd6675c8ba3e5b458e78095d271a10cd38b6a", size = 679700 },- { url = "https://files.pythonhosted.org/packages/08/a3/1b26c438c78821e5a82b9c02f7b19a86097aeb2c51132d06e159acc22dc2/pyobjc_core-12.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5c617551e0ab860c49229fcec0135a5cde702485f22254ddc17205eb24b7fc55", size = 721370 },- { url = "https://files.pythonhosted.org/packages/35/b1/6df7d4b0d9f0088855a59f6af59230d1191f78fa84ca68851723272f1916/pyobjc_core-12.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c2709ff43ac5c2e9e2c574ae515d3aa0e470345847a4d96c5d4a04b1b86e966d", size = 672302 },- { url = "https://files.pythonhosted.org/packages/f8/10/3a029797c0a22c730ee0d0149ac34ab27afdf51667f96aa23a8ebe7dc3c9/pyobjc_core-12.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:eb6b987e53291e7cafd8f71a80a2dd44d7afec4202a143a3e47b75cb9cdb5716", size = 713255 },+ { url = "https://files.pythonhosted.org/packages/95/df/d2b290708e9da86d6e7a9a2a2022b91915cf2e712a5a82e306cb6ee99792/pyobjc_core-12.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c918ebca280925e7fcb14c5c43ce12dcb9574a33cccb889be7c8c17f3bcce8b6", size = 671263, upload-time = "2025-11-14T09:31:35.231Z" },+ { url = "https://files.pythonhosted.org/packages/64/5a/6b15e499de73050f4a2c88fff664ae154307d25dc04da8fb38998a428358/pyobjc_core-12.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:818bcc6723561f207e5b5453efe9703f34bc8781d11ce9b8be286bb415eb4962", size = 678335, upload-time = "2025-11-14T09:32:20.107Z" },+ { url = "https://files.pythonhosted.org/packages/f4/d2/29e5e536adc07bc3d33dd09f3f7cf844bf7b4981820dc2a91dd810f3c782/pyobjc_core-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:01c0cf500596f03e21c23aef9b5f326b9fb1f8f118cf0d8b66749b6cf4cbb37a", size = 677370, upload-time = "2025-11-14T09:33:05.273Z" },+ { url = "https://files.pythonhosted.org/packages/1b/f0/4b4ed8924cd04e425f2a07269943018d43949afad1c348c3ed4d9d032787/pyobjc_core-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:177aaca84bb369a483e4961186704f64b2697708046745f8167e818d968c88fc", size = 719586, upload-time = "2025-11-14T09:33:53.302Z" },+ { url = "https://files.pythonhosted.org/packages/25/98/9f4ed07162de69603144ff480be35cd021808faa7f730d082b92f7ebf2b5/pyobjc_core-12.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:844515f5d86395b979d02152576e7dee9cc679acc0b32dc626ef5bda315eaa43", size = 670164, upload-time = "2025-11-14T09:34:37.458Z" },+ { url = "https://files.pythonhosted.org/packages/62/50/dc076965c96c7f0de25c0a32b7f8aa98133ed244deaeeacfc758783f1f30/pyobjc_core-12.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:453b191df1a4b80e756445b935491b974714456ae2cbae816840bd96f86db882", size = 712204, upload-time = "2025-11-14T09:35:24.148Z" },][[package]]name = "pyobjc-framework-avfoundation"-version = "12.0"+version = "12.1"source = { registry = "https://pypi.org/simple" }dependencies = [- { name = "pyobjc-core", marker = "platform_system == 'Darwin'" },- { name = "pyobjc-framework-cocoa", marker = "platform_system == 'Darwin'" },- { name = "pyobjc-framework-coreaudio", marker = "platform_system == 'Darwin'" },- { name = "pyobjc-framework-coremedia", marker = "platform_system == 'Darwin'" },- { name = "pyobjc-framework-quartz", marker = "platform_system == 'Darwin'" },+ { name = "pyobjc-core", marker = "sys_platform == 'darwin'" },+ { name = "pyobjc-framework-cocoa", marker = "sys_platform == 'darwin'" },+ { name = "pyobjc-framework-coreaudio", marker = "sys_platform == 'darwin'" },+ { name = "pyobjc-framework-coremedia", marker = "sys_platform == 'darwin'" },+ { name = "pyobjc-framework-quartz", marker = "sys_platform == 'darwin'" },]-sdist = { url = "https://files.pythonhosted.org/packages/d9/95/29d3dbf7bfa6f2beb865ab4ce22ee1ccd58c2036a6c4caa6fa6568c7a727/pyobjc_framework_avfoundation-12.0.tar.gz", hash = "sha256:e9e9a15edea43341b39de677a58ac98b2a6bd4d6c55176b4804c5f75b3d20ece", size = 310508 }+sdist = { url = "https://files.pythonhosted.org/packages/cd/42/c026ab308edc2ed5582d8b4b93da6b15d1b6557c0086914a4aabedd1f032/pyobjc_framework_avfoundation-12.1.tar.gz", hash = "sha256:eda0bb60be380f9ba2344600c4231dd58a3efafa99fdc65d3673ecfbb83f6fcb", size = 310047, upload-time = "2025-11-14T10:09:40.069Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/ed/b6/cd14afee737a14b959ec9f96017134b80bdab55649b82f34f5490c060790/pyobjc_framework_avfoundation-12.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d47cd250011e6db5e20f1ff6ad72b6d2c40364eb6565009c7d2ff071e0a89647", size = 83319 },- { url = "https://files.pythonhosted.org/packages/8c/3c/f9c732a33cafeff870e8d99c2378cc90a51f1a3261b5614f414b36902fdc/pyobjc_framework_avfoundation-12.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:803e675fbea532337bbd94becb040a054d58af610e20e86f7fd35fb54fd379f2", size = 83370 },- { url = "https://files.pythonhosted.org/packages/dd/a3/07b098df03c1d5d8b4762ccba77881c9d41733a94db34815a27853531bf8/pyobjc_framework_avfoundation-12.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:3aef07f73e8e908aeae195846d0d9bddb95bf82bbc10c22b51ec15f822a828fd", size = 83413 },- { url = "https://files.pythonhosted.org/packages/57/64/bffe9c7980313c84ef66f1c97770c12c505bc91a7e188a401f8655e85f91/pyobjc_framework_avfoundation-12.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:31840a514e703f64094c9f29053a0a22969b4666a207b5061d965fa0ddb96e4d", size = 83866 },- { url = "https://files.pythonhosted.org/packages/e8/5a/40edf86b2c040070ca18c9eec2e2c52e7d111209279fee919b13ad86d2b2/pyobjc_framework_avfoundation-12.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:953bb5d6db3a6e2cddf489eb58bb6a1fb306e441ba6a011d04356b25c60a78e4", size = 83625 },- { url = "https://files.pythonhosted.org/packages/2d/6d/c6398333f88e2142d18ca9704413c5aa10d86fbc5ed813ded61da70104bc/pyobjc_framework_avfoundation-12.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a612ae9863abd4e0769ce6ff9960a5bf46128dddb3ef8f027406b8cd136e41f9", size = 83962 },+ { url = "https://files.pythonhosted.org/packages/9a/5a/4ef36b309138840ff8cd85364f66c29e27023f291004c335a99f6e87e599/pyobjc_framework_avfoundation-12.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:82cc2c2d9ab6cc04feeb4700ff251d00f1fcafff573c63d4e87168ff80adb926", size = 83328, upload-time = "2025-11-14T09:37:40.808Z" },+ { url = "https://files.pythonhosted.org/packages/a6/00/ca471e5dd33f040f69320832e45415d00440260bf7f8221a9df4c4662659/pyobjc_framework_avfoundation-12.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bf634f89265b4d93126153200d885b6de4859ed6b3bc65e69ff75540bc398406", size = 83375, upload-time = "2025-11-14T09:37:47.262Z" },+ { url = "https://files.pythonhosted.org/packages/b3/d4/ade88067deff45858b457648dd82c9363977eb1915efd257232cd06bdac1/pyobjc_framework_avfoundation-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f8ac7f7e0884ac8f12009cdb9d4fefc2f269294ab2ccfd84520a560859b69cec", size = 83413, upload-time = "2025-11-14T09:37:53.759Z" },+ { url = "https://files.pythonhosted.org/packages/a7/3a/fa699d748d6351fa0aeca656ea2f9eacc36e31203dfa56bc13c8a3d26d7d/pyobjc_framework_avfoundation-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:51aba2c6816badfb1fb5a2de1b68b33a23f065bf9e3b99d46ede0c8c774ac7a4", size = 83860, upload-time = "2025-11-14T09:38:00.051Z" },+ { url = "https://files.pythonhosted.org/packages/0c/65/a79cf3b8935a78329ac1107056b91868a581096a90ab6ddff5fd28db4947/pyobjc_framework_avfoundation-12.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:9a3ffd1ae90bd72dbcf2875aa9254369e805b904140362a7338ebf1af54201a6", size = 83629, upload-time = "2025-11-14T09:38:06.697Z" },+ { url = "https://files.pythonhosted.org/packages/8a/03/4125204a17cd7b4de1fdfc38b280a47d0d8f8691a4ee306ebb41b58ff030/pyobjc_framework_avfoundation-12.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:394c99876b9a38db4851ddf8146db363556895c12e9c711ccd3c3f907ac8e273", size = 83962, upload-time = "2025-11-14T09:38:13.153Z" },][[package]]name = "pyobjc-framework-cocoa"-version = "12.0"+version = "12.1"source = { registry = "https://pypi.org/simple" }dependencies = [- { name = "pyobjc-core", marker = "platform_system == 'Darwin'" },+ { name = "pyobjc-core", marker = "sys_platform == 'darwin'" },]-sdist = { url = "https://files.pythonhosted.org/packages/37/6f/89837da349fe7de6476c426f118096b147de923139556d98af1832c64b97/pyobjc_framework_cocoa-12.0.tar.gz", hash = "sha256:02d69305b698015a20fcc8e1296e1528e413d8cf9fdcd590478d359386d76e8a", size = 2771906 }+sdist = { url = "https://files.pythonhosted.org/packages/02/a3/16ca9a15e77c061a9250afbae2eae26f2e1579eb8ca9462ae2d2c71e1169/pyobjc_framework_cocoa-12.1.tar.gz", hash = "sha256:5556c87db95711b985d5efdaaf01c917ddd41d148b1e52a0c66b1a2e2c5c1640", size = 2772191, upload-time = "2025-11-14T10:13:02.069Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/8d/7d/1758df5c2cbf9a0a447cab7e9e5690f166c8b2117dc15d8f38a9526af9db/pyobjc_framework_cocoa-12.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ae041b7c64a8fa93f0e06728681f7ad657ef2c92dcfdf8abc073d89fb6e3910b", size = 383765 },- { url = "https://files.pythonhosted.org/packages/18/76/ee7a07e64f7afeff36bf2efe66caed93e41fcaa2b23fc89c4746387e4a0d/pyobjc_framework_cocoa-12.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ed99d53a91f9feb9452ba8942cd09d86727f6dd2d56ecfd9b885ddbd4259ebdd", size = 384540 },- { url = "https://files.pythonhosted.org/packages/fb/29/cfef5f021576976698c6ae195fa304238b9f6716e1b3eb11258d2572afe9/pyobjc_framework_cocoa-12.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:13e573f5093f4158f305b1bac5e1f783881ce2f5f4a69f3c80cb000f76731259", size = 384659 },- { url = "https://files.pythonhosted.org/packages/f1/37/d2d9a143ab5387815a00f478916a52425c4792678366ef6cedf20b8cc9cd/pyobjc_framework_cocoa-12.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:3b167793cd1b509eaf693140ace9be1f827a2c8686fceb8c599907661f608bc2", size = 388787 },- { url = "https://files.pythonhosted.org/packages/0f/15/0a6122e430d0e2ba27ad0e345b89f85346805f39d6f97eea6430a74350d9/pyobjc_framework_cocoa-12.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:a2b6fb9ab3e5ab6db04dfa17828a97894e7da85dd8600885c72a0c2c2214d618", size = 384890 },- { url = "https://files.pythonhosted.org/packages/79/d7/1a3ad814d427c08b99405e571e47a0219598930ad73850ac02d164d88cd0/pyobjc_framework_cocoa-12.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:32ff10250a57f72a0b6eca85b790dcc87548ff71d33d0436ffb69680d5e2f308", size = 388925 },+ { url = "https://files.pythonhosted.org/packages/3f/07/5760735c0fffc65107e648eaf7e0991f46da442ac4493501be5380e6d9d4/pyobjc_framework_cocoa-12.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f52228bcf38da64b77328787967d464e28b981492b33a7675585141e1b0a01e6", size = 383812, upload-time = "2025-11-14T09:40:53.169Z" },+ { url = "https://files.pythonhosted.org/packages/95/bf/ee4f27ec3920d5c6fc63c63e797c5b2cc4e20fe439217085d01ea5b63856/pyobjc_framework_cocoa-12.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:547c182837214b7ec4796dac5aee3aa25abc665757b75d7f44f83c994bcb0858", size = 384590, upload-time = "2025-11-14T09:41:17.336Z" },+ { url = "https://files.pythonhosted.org/packages/ad/31/0c2e734165abb46215797bd830c4bdcb780b699854b15f2b6240515edcc6/pyobjc_framework_cocoa-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5a3dcd491cacc2f5a197142b3c556d8aafa3963011110102a093349017705118", size = 384689, upload-time = "2025-11-14T09:41:41.478Z" },+ { url = "https://files.pythonhosted.org/packages/23/3b/b9f61be7b9f9b4e0a6db18b3c35c4c4d589f2d04e963e2174d38c6555a92/pyobjc_framework_cocoa-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:914b74328c22d8ca261d78c23ef2befc29776e0b85555973927b338c5734ca44", size = 388843, upload-time = "2025-11-14T09:42:05.719Z" },+ { url = "https://files.pythonhosted.org/packages/59/bb/f777cc9e775fc7dae77b569254570fe46eb842516b3e4fe383ab49eab598/pyobjc_framework_cocoa-12.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:03342a60fc0015bcdf9b93ac0b4f457d3938e9ef761b28df9564c91a14f0129a", size = 384932, upload-time = "2025-11-14T09:42:29.771Z" },+ { url = "https://files.pythonhosted.org/packages/58/27/b457b7b37089cad692c8aada90119162dfb4c4a16f513b79a8b2b022b33b/pyobjc_framework_cocoa-12.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:6ba1dc1bfa4da42d04e93d2363491275fb2e2be5c20790e561c8a9e09b8cf2cc", size = 388970, upload-time = "2025-11-14T09:42:53.964Z" },][[package]]name = "pyobjc-framework-coreaudio"-version = "12.0"+version = "12.1"source = { registry = "https://pypi.org/simple" }dependencies = [- { name = "pyobjc-core", marker = "platform_system == 'Darwin'" },- { name = "pyobjc-framework-cocoa", marker = "platform_system == 'Darwin'" },+ { name = "pyobjc-core", marker = "sys_platform == 'darwin'" },+ { name = "pyobjc-framework-cocoa", marker = "sys_platform == 'darwin'" },]-sdist = { url = "https://files.pythonhosted.org/packages/4c/a0/604b8e2e53f46536b9045fc0fbfa9468a606910c9c0a238d0f3d31071d87/pyobjc_framework_coreaudio-12.0.tar.gz", hash = "sha256:19741907d2d80a658d3721140eb998061007955323b427afca67eda0e2ad3215", size = 75415 }+sdist = { url = "https://files.pythonhosted.org/packages/84/d1/0b884c5564ab952ff5daa949128c64815300556019c1bba0cf2ca752a1a0/pyobjc_framework_coreaudio-12.1.tar.gz", hash = "sha256:a9e72925fcc1795430496ce0bffd4ddaa92c22460a10308a7283ade830089fe1", size = 75077, upload-time = "2025-11-14T10:13:22.345Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/e4/42/284cc68a2bd310f4399eb92e5259319a3131b1fba5f1496dfaa477eaaed0/pyobjc_framework_coreaudio-12.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d6287d67c7b3ca9abf4b7e8a64e1a05e97ebcb52b32e92a78e1e825d1334ec56", size = 35337 },- { url = "https://files.pythonhosted.org/packages/51/49/97cbda2efdb02e9d8c8507dc980040056b96ca9604dab41cbed3c874fe4a/pyobjc_framework_coreaudio-12.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:c89762834680a26436a8e435dc736b509f1c3aa3927f66db85d3289995d007d2", size = 36920 },- { url = "https://files.pythonhosted.org/packages/52/c1/8bd4c6a917d7314042a7b26f3433c680c051f64995da682a5f99502202c9/pyobjc_framework_coreaudio-12.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f7309087b42ce6c399d2971a7173c9216c03a43a998bb2be2eecc90fb362ccb2", size = 36944 },- { url = "https://files.pythonhosted.org/packages/84/92/23ab5d0f3b953bb944d7bbb99d054c560b9a2d931d173e9165b44172ebb8/pyobjc_framework_coreaudio-12.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b52a2ef28b557c5f5cbf97264ce0c6f8ce1a4ea0309b4a952122b9bc3a4ad636", size = 38398 },- { url = "https://files.pythonhosted.org/packages/e2/14/d7f6b39f0234de213889df52091681b9abab9e4b7ca6858eff1cbe5e3c14/pyobjc_framework_coreaudio-12.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:30ac30f6be6b35bbe7f21c055269de6643c378c5e15bf5002c4eb1de942904fc", size = 37021 },- { url = "https://files.pythonhosted.org/packages/34/ee/f1e955191775df1cdac142bfca1dc2787c9dde9f23e821061c7a18ff6e86/pyobjc_framework_coreaudio-12.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:1bb16d186466cf3b9c23e29dbc0470c282c7194dc022b685f075a7585dfc8a43", size = 38498 },+ { url = "https://files.pythonhosted.org/packages/9e/25/491ff549fd9a40be4416793d335bff1911d3d1d1e1635e3b0defbd2cf585/pyobjc_framework_coreaudio-12.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a452de6b509fa4a20160c0410b72330ac871696cd80237883955a5b3a4de8f2a", size = 35327, upload-time = "2025-11-14T09:43:32.523Z" },+ { url = "https://files.pythonhosted.org/packages/a9/48/05b5192122e23140cf583eac99ccc5bf615591d6ff76483ba986c38ee750/pyobjc_framework_coreaudio-12.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a5ad6309779663f846ab36fe6c49647e470b7e08473c3e48b4f004017bdb68a4", size = 36908, upload-time = "2025-11-14T09:43:36.108Z" },+ { url = "https://files.pythonhosted.org/packages/3d/ce/45808618fefc760e2948c363e0a3402ff77690c8934609cd07b19bc5b15f/pyobjc_framework_coreaudio-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:3d8ef424850c8ae2146f963afaec6c4f5bf0c2e412871e68fb6ecfb209b8376f", size = 36935, upload-time = "2025-11-14T09:43:39.414Z" },+ { url = "https://files.pythonhosted.org/packages/bf/f6/0d74d9464bfb4f39451abf745174ec0c4d5c5ebf1c2fcb7556263ae3f75a/pyobjc_framework_coreaudio-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:6552624df39dbc68ff9328f244ba56f59234ecbde8455db1e617a71bc4f3dd3a", size = 38390, upload-time = "2025-11-14T09:43:43.194Z" },+ { url = "https://files.pythonhosted.org/packages/cf/f2/c5ca32d01c9d892bf189cfe9b17deaf996db3b4013f8a8ba9b0d22730d70/pyobjc_framework_coreaudio-12.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:78ea67483a5deb21625c189328152008d278fe1da4304da9fcc1babd12627038", size = 37012, upload-time = "2025-11-14T09:43:46.54Z" },+ { url = "https://files.pythonhosted.org/packages/00/be/c3d660cef1ef874f42057a74931a7a05f581f6a647f5209bef96b372db86/pyobjc_framework_coreaudio-12.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:8d81b0d0296ab4571a4ff302e5cdb52386e486eb8749e99b95b9141438558ca2", size = 38485, upload-time = "2025-11-14T09:43:49.883Z" },][[package]]name = "pyobjc-framework-coremedia"-version = "12.0"+version = "12.1"source = { registry = "https://pypi.org/simple" }dependencies = [- { name = "pyobjc-core", marker = "platform_system == 'Darwin'" },- { name = "pyobjc-framework-cocoa", marker = "platform_system == 'Darwin'" },+ { name = "pyobjc-core", marker = "sys_platform == 'darwin'" },+ { name = "pyobjc-framework-cocoa", marker = "sys_platform == 'darwin'" },]-sdist = { url = "https://files.pythonhosted.org/packages/55/6d/ed4f8b525a0520e609cea57fd0677bf7792e168297ad5577df1088eb7cd6/pyobjc_framework_coremedia-12.0.tar.gz", hash = "sha256:d7f76d2eb2890be9f8836b95682e83fa7f158c92043958daa71845fbc4a01ba9", size = 89928 }+sdist = { url = "https://files.pythonhosted.org/packages/da/7d/5ad600ff7aedfef8ba8f51b11d9aaacdf247b870bd14045d6e6f232e3df9/pyobjc_framework_coremedia-12.1.tar.gz", hash = "sha256:166c66a9c01e7a70103f3ca44c571431d124b9070612ef63a1511a4e6d9d84a7", size = 89566, upload-time = "2025-11-14T10:13:49.788Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/05/1c/5e5fe69b142c98b844803a0579cbd8ea555d1bfeecede95a918e58bdfb67/pyobjc_framework_coremedia-12.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ed5684c764e1d4eab10cfd8dcaea82b598a85d7757cef35d36e6c78a4bd4b1e5", size = 29508 },- { url = "https://files.pythonhosted.org/packages/ec/15/9853b2e75db0bf47a80412f9584a84966310e3168dabde8d43f2c6fa9ff1/pyobjc_framework_coremedia-12.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:06e824c97391cacacfe6be4b80acdcb6924a8087d03d9af35ea0edf502f2ada1", size = 29406 },- { url = "https://files.pythonhosted.org/packages/eb/08/15d500b9325f8c22ed379dba21559dfa9c7430c9b7eb709a55e515648c8d/pyobjc_framework_coremedia-12.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:4d10a8b551626ae99a67436de498fc06a0beaa66db065baed19d7dfc5f1db44f", size = 29425 },- { url = "https://files.pythonhosted.org/packages/a9/98/ccf63a3a3aff8fce8be57b8ae1a67c9872e278a890c0508e86ed6bf98055/pyobjc_framework_coremedia-12.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:370aece067a0fb85e54eed57c6ca84118a55e7ff697988e5c82358d1bd3b648a", size = 29486 },- { url = "https://files.pythonhosted.org/packages/8f/fb/43b2a78ffdcb1eed7f04c317f9675d40dcd573f805d7385fec6c54005a2d/pyobjc_framework_coremedia-12.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:0c89ca9d7cedd7b37178e358c83332933fcd65d82c362244aa208383724dce6f", size = 29462 },- { url = "https://files.pythonhosted.org/packages/2f/2b/3cb4ba97483987b6dd9165e2da0f5e85f81044bd8fba26c409271dc2c880/pyobjc_framework_coremedia-12.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:aaa904d82f75f1e38a1ba8ba9a19a5acb3869304626b12fd6b60040a85188211", size = 29512 },+ { url = "https://files.pythonhosted.org/packages/c8/bc/e66de468b3777d8fece69279cf6d2af51d2263e9a1ccad21b90c35c74b1b/pyobjc_framework_coremedia-12.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ee7b822c9bb674b5b0a70bfb133410acae354e9241b6983f075395f3562f3c46", size = 29503, upload-time = "2025-11-14T09:44:54.716Z" },+ { url = "https://files.pythonhosted.org/packages/c8/ae/f773cdc33c34a3f9ce6db829dbf72661b65c28ea9efaec8940364185b977/pyobjc_framework_coremedia-12.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:161a627f5c8cd30a5ebb935189f740e21e6cd94871a9afd463efdb5d51e255fa", size = 29396, upload-time = "2025-11-14T09:44:57.563Z" },+ { url = "https://files.pythonhosted.org/packages/a5/ea/aee26a475b4af8ed4152d3c50b1b8955241b8e95ae789aa9ee296953bc6a/pyobjc_framework_coremedia-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:98e885b7a092083fceaef0a7fc406a01ba7bcd3318fb927e59e055931c99cac8", size = 29414, upload-time = "2025-11-14T09:45:01.336Z" },+ { url = "https://files.pythonhosted.org/packages/db/9d/5ff10ee0ff539e125c96b8cff005457558766f942919814c968c3367cc32/pyobjc_framework_coremedia-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:d2b84149c1b3e65ec9050a3e5b617e6c0b4cdad2ab622c2d8c5747a20f013e16", size = 29477, upload-time = "2025-11-14T09:45:04.218Z" },+ { url = "https://files.pythonhosted.org/packages/08/e2/b890658face1290c8b6b6b53a1159c822bece248f883e42302548bef38da/pyobjc_framework_coremedia-12.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:737ec6e0b63414f42f7188030c85975d6d2124fbf6b15b52c99b6cc20250af4d", size = 29447, upload-time = "2025-11-14T09:45:07.17Z" },+ { url = "https://files.pythonhosted.org/packages/a4/9e/16981d0ee04b182481ce1e497b5e0326bad6d698fe0265bb7db72b1b26b5/pyobjc_framework_coremedia-12.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:6a9419e0d143df16a1562520a13a389417386e2a53031530af6da60c34058ced", size = 29500, upload-time = "2025-11-14T09:45:10.506Z" },][[package]]name = "pyobjc-framework-quartz"-version = "12.0"+version = "12.1"source = { registry = "https://pypi.org/simple" }dependencies = [- { name = "pyobjc-core", marker = "platform_system == 'Darwin'" },- { name = "pyobjc-framework-cocoa", marker = "platform_system == 'Darwin'" },+ { name = "pyobjc-core", marker = "sys_platform == 'darwin'" },+ { name = "pyobjc-framework-cocoa", marker = "sys_platform == 'darwin'" },]-sdist = { url = "https://files.pythonhosted.org/packages/91/0b/3c34fc9de790daff5ca49d1f36cb8dcc353ac10e4e29b4759e397a3831f4/pyobjc_framework_quartz-12.0.tar.gz", hash = "sha256:5bcb9e78d671447e04d89e2e3c39f3135157892243facc5f8468aa333e40d67f", size = 3159509 }+sdist = { url = "https://files.pythonhosted.org/packages/94/18/cc59f3d4355c9456fc945eae7fe8797003c4da99212dd531ad1b0de8a0c6/pyobjc_framework_quartz-12.1.tar.gz", hash = "sha256:27f782f3513ac88ec9b6c82d9767eef95a5cf4175ce88a1e5a65875fee799608", size = 3159099, upload-time = "2025-11-14T10:21:24.31Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/b8/ed/13207ed99bd672a681cad3435512ab4e3217dd0cdc991c16a074ef6e7e95/pyobjc_framework_quartz-12.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6098bdb5db5837ecf6cf57f775efa9e5ce7c31f6452e4c4393de2198f5a3b06b", size = 217787 },- { url = "https://files.pythonhosted.org/packages/1c/76/2d7e6b0e2eb42b9a17b65c92575693f9d364b832e069024123742b54caa5/pyobjc_framework_quartz-12.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:cb6818cbeea55e8b85c3347bb8acaf6f46ebb2c241ae4eb76ba1358c68f3ec5c", size = 218816 },- { url = "https://files.pythonhosted.org/packages/60/d8/05f8fb5f27af69c0b5a9802f220a7c00bbe595c790e13edefa042603b957/pyobjc_framework_quartz-12.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ece7a05aa2bfc3aa215f1a7c8580e873f3867ba40d0006469618cc2ceb796578", size = 219201 },- { url = "https://files.pythonhosted.org/packages/7e/3f/1228f86de266874e20c04f04736a5f11c5a29a1839efde594ba4097d0255/pyobjc_framework_quartz-12.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:f1b2e34f6f0dd023f80a0e875af4dab0ad27fccac239da9ad3d311a2d2578e27", size = 224330 },- { url = "https://files.pythonhosted.org/packages/8a/23/ec1804bd10c409fe98ba086329569914fd10b6814208ca6168e81ca0ec1a/pyobjc_framework_quartz-12.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:a2cde43ddc5d2a9ace13af38b4a9ee70dbd47d1707ec6b7185a1a3a1d48e54f9", size = 219581 },- { url = "https://files.pythonhosted.org/packages/86/c2/cf89fda2e477c0c4e2a8aae86202c2891a83bead24e8a7fc733ff490dffc/pyobjc_framework_quartz-12.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9b928d551ec779141558d986684c19f8f5742251721f440d7087257e4e35b22b", size = 224613 },+ { url = "https://files.pythonhosted.org/packages/b7/ef/dcd22b743e38b3c430fce4788176c2c5afa8bfb01085b8143b02d1e75201/pyobjc_framework_quartz-12.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:19f99ac49a0b15dd892e155644fe80242d741411a9ed9c119b18b7466048625a", size = 217795, upload-time = "2025-11-14T09:59:46.922Z" },+ { url = "https://files.pythonhosted.org/packages/e9/9b/780f057e5962f690f23fdff1083a4cfda5a96d5b4d3bb49505cac4f624f2/pyobjc_framework_quartz-12.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:7730cdce46c7e985535b5a42c31381af4aa6556e5642dc55b5e6597595e57a16", size = 218798, upload-time = "2025-11-14T10:00:01.236Z" },+ { url = "https://files.pythonhosted.org/packages/ba/2d/e8f495328101898c16c32ac10e7b14b08ff2c443a756a76fd1271915f097/pyobjc_framework_quartz-12.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:629b7971b1b43a11617f1460cd218bd308dfea247cd4ee3842eb40ca6f588860", size = 219206, upload-time = "2025-11-14T10:00:15.623Z" },+ { url = "https://files.pythonhosted.org/packages/67/43/b1f0ad3b842ab150a7e6b7d97f6257eab6af241b4c7d14cb8e7fde9214b8/pyobjc_framework_quartz-12.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:53b84e880c358ba1ddcd7e8d5ea0407d760eca58b96f0d344829162cda5f37b3", size = 224317, upload-time = "2025-11-14T10:00:30.703Z" },+ { url = "https://files.pythonhosted.org/packages/4a/00/96249c5c7e5aaca5f688ca18b8d8ad05cd7886ebd639b3c71a6a4cadbe75/pyobjc_framework_quartz-12.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:42d306b07f05ae7d155984503e0fb1b701fecd31dcc5c79fe8ab9790ff7e0de0", size = 219558, upload-time = "2025-11-14T10:00:45.476Z" },+ { url = "https://files.pythonhosted.org/packages/4d/a6/708a55f3ff7a18c403b30a29a11dccfed0410485a7548c60a4b6d4cc0676/pyobjc_framework_quartz-12.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0cc08fddb339b2760df60dea1057453557588908e42bdc62184b6396ce2d6e9a", size = 224580, upload-time = "2025-11-14T10:01:00.091Z" },][[package]]name = "pyparsing"-version = "3.2.5"+version = "3.3.2"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/f2/a5/181488fc2b9d093e3972d2a472855aae8a03f000592dbfce716a512b3359/pyparsing-3.2.5.tar.gz", hash = "sha256:2df8d5b7b2802ef88e8d016a2eb9c7aeaa923529cd251ed0fe4608275d4105b6", size = 1099274 }+sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/10/5e/1aa9a93198c6b64513c9d7752de7422c06402de6600a8767da1524f9570b/pyparsing-3.2.5-py3-none-any.whl", hash = "sha256:e38a4f02064cf41fe6593d328d0512495ad1f3d8a91c4f73fc401b3079a59a5e", size = 113890 },+ { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" },+]++[[package]]+name = "pyproject-hooks"+version = "1.2.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/e7/82/28175b2414effca1cdac8dc99f76d660e7a4fb0ceefa4b4ab8f5f6742925/pyproject_hooks-1.2.0.tar.gz", hash = "sha256:1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8", size = 19228, upload-time = "2024-09-29T09:24:13.293Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", hash = "sha256:9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913", size = 10216, upload-time = "2024-09-29T09:24:11.978Z" },][[package]]name = "pyqt6"-version = "6.10.0"+version = "6.10.2"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "pyqt6-qt6" },{ name = "pyqt6-sip" },]-sdist = { url = "https://files.pythonhosted.org/packages/f2/57/48985490c01584e00b70040ec0eb02dfe950471097201acb1b65deb633e5/pyqt6-6.10.0.tar.gz", hash = "sha256:710ecfd720d9a03b2c684881ae37f528e11d17e8f1bf96431d00a6a73f308e36", size = 1079921 }+sdist = { url = "https://files.pythonhosted.org/packages/96/03/e756f52e8b0d7bb5527baf8c46d59af0746391943bdb8655acba22ee4168/pyqt6-6.10.2.tar.gz", hash = "sha256:6c0db5d8cbb9a3e7e2b5b51d0ff3f283121fa27b864db6d2f35b663c9be5cc83", size = 1085573, upload-time = "2026-01-08T16:40:00.244Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/f8/99/ca0386e84e39e4f2ef30322f1d39d515f2a3efbc542cccb33e65a1cf7c46/pyqt6-6.10.0-1-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:54b6b022369e4e6ade8cf79c0f988558839df7b2c285f814b4567d15a0fcb756", size = 37745881 },- { url = "https://files.pythonhosted.org/packages/66/48/be73fb730c6f617f456ab73150db384b17a7a08394d7e2ded55f42de8a7b/pyqt6-6.10.0-cp39-abi3-macosx_10_14_universal2.whl", hash = "sha256:0eb82f152a83a8ae39f7d3ba580829ff7c0e8179d19d70f396853c10c8ddc5ac", size = 59987475 },- { url = "https://files.pythonhosted.org/packages/00/31/e55f7b718df92423b5af3f0fe11e770e56d7576c03adc6b6866b0e8beb46/pyqt6-6.10.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:43e94a0ad4713055b47b4676d23432349845729912e4f3d20ac95935931c5e6f", size = 39028922 },- { url = "https://files.pythonhosted.org/packages/cf/3d/48465697f530addaeaf41f4d5b3e54108ebabd18ab6da19823de5099e807/pyqt6-6.10.0-cp39-abi3-manylinux_2_39_aarch64.whl", hash = "sha256:357da0f1465557dde249a31bc1f152320b7628a644e1d55d2db09b635394f39f", size = 40619932 },- { url = "https://files.pythonhosted.org/packages/fb/e4/0c4745cd0b31c17bd85d5da697404679f4faa6424aa7b57112277c1e8027/pyqt6-6.10.0-cp39-abi3-win_amd64.whl", hash = "sha256:8b5e4ea573733017a76bd12ea1b53351fd7f6dc57f8abf4329c4a41fea6dde04", size = 25816996 },- { url = "https://files.pythonhosted.org/packages/b0/40/0891706e69c60267b6933465fa299138bafa72324d6855c6962ca05a5f9f/pyqt6-6.10.0-cp39-abi3-win_arm64.whl", hash = "sha256:c2b5fc1a028e95b096f3a5966611cc8194e8e9e69984c41477417e18b5ce1362", size = 25663908 },+ { url = "https://files.pythonhosted.org/packages/fb/3f/f073a980969aa485ef288eb2e3b94c223ba9c7ac9941543f19b51659b98d/pyqt6-6.10.2-cp39-abi3-macosx_10_14_universal2.whl", hash = "sha256:37ae7c1183fe4dd0c6aefd2006a35731245de1cb6f817bb9e414a3e4848dfd6d", size = 60244482, upload-time = "2026-01-08T16:38:50.837Z" },+ { url = "https://files.pythonhosted.org/packages/ec/3e/9a015651ec71cea2e2f960c37edeb21623ba96a74956c0827def837f7c6b/pyqt6-6.10.2-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:78e1b3d5763e4cbc84485aef600e0aba5e1932fd263b716f92cd1a40dfa5e924", size = 37899440, upload-time = "2026-01-08T16:39:09.027Z" },+ { url = "https://files.pythonhosted.org/packages/51/74/a88fec2b99700270ca5d7dc7d650236a4990ed6fc88e055ca0fc8a339ee3/pyqt6-6.10.2-cp39-abi3-manylinux_2_39_aarch64.whl", hash = "sha256:bbc3af541bbecd27301bfe69fe445aa1611a9b490bd3de77306b12df632f7ec6", size = 40748467, upload-time = "2026-01-08T16:39:29.551Z" },+ { url = "https://files.pythonhosted.org/packages/75/34/be7a55529607b21db00a49ca53cb07c3092d2a5a95ea19bb95cfa0346904/pyqt6-6.10.2-cp39-abi3-win_amd64.whl", hash = "sha256:bd328cb70bc382c48861cd5f0a11b2b8ae6f5692d5a2d6679ba52785dced327b", size = 26015391, upload-time = "2026-01-08T16:39:42.946Z" },+ { url = "https://files.pythonhosted.org/packages/af/de/d9c88f976602b7884fec4ad54a4575d48e23e4f390e5357ea83917358846/pyqt6-6.10.2-cp39-abi3-win_arm64.whl", hash = "sha256:7901ba1df024b7ee9fdacfb2b7661aeb3749ae8b0bef65428077de3e0450eabb", size = 26208415, upload-time = "2026-01-08T16:39:57.751Z" },][[package]]name = "pyqt6-qt6"-version = "6.10.0"+version = "6.10.2"source = { registry = "https://pypi.org/simple" }wheels = [- { url = "https://files.pythonhosted.org/packages/c3/b2/309ba75490d614530f10a5b922555374098706364ec1cc411f98068beb4d/pyqt6_qt6-6.10.0-py3-none-macosx_10_14_x86_64.whl", hash = "sha256:9b48d9eba795a78d21393b1909e7a0406512038ea4667463e4882e284bf95817", size = 68426539 },- { url = "https://files.pythonhosted.org/packages/25/20/1de54c91f6f34be6042bdb6913c71e253a6bddf002d8aa78cb1acc67f5a8/pyqt6_qt6-6.10.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:768ced73dbb2c85e6d72ea63fd7409ba934d4b24580ef073a3eb16fd88d3fe70", size = 62509741 },- { url = "https://files.pythonhosted.org/packages/c1/32/1d84ab75795b0984935e32d2a51200b94328a45954c28360a97d02f1c376/pyqt6_qt6-6.10.0-py3-none-manylinux_2_34_x86_64.whl", hash = "sha256:cd38b281bb7229b8114f13126aacd77f831a97105fdb1d900260a48ead8c9fcd", size = 83787113 },- { url = "https://files.pythonhosted.org/packages/d9/56/e8daedfb0e4a79e19500b6271958b915389360b39a3e2847961828d2e0b3/pyqt6_qt6-6.10.0-py3-none-manylinux_2_39_aarch64.whl", hash = "sha256:497df665091451ab7fde3355e262b243d2a2d97924b899a5cbb193a0cc573b7e", size = 82848172 },- { url = "https://files.pythonhosted.org/packages/0b/82/bbbee33205574f57b17c25059c6b8726a129961b55a1fe34f9216b4b0a70/pyqt6_qt6-6.10.0-py3-none-win_amd64.whl", hash = "sha256:d11bc03908cacbd2e3426289ad51dcf6d2896af6ffec595626ce9cf9b93e770d", size = 76322424 },- { url = "https://files.pythonhosted.org/packages/f2/b7/fb3172c8e85fdcdc942600dbec3d7ebd8d5224159cd4f32ced6cc43949cc/pyqt6_qt6-6.10.0-py3-none-win_arm64.whl", hash = "sha256:7f3ae89337e905dba436c226027ebd8777d4cdeef386131ad9a1b0a53ecc1a81", size = 56552467 },+ { url = "https://files.pythonhosted.org/packages/9a/eb/f04d547d8ed9f20c7b246db4ef5d93b49cab4692009a10652ed0a8b9d2aa/pyqt6_qt6-6.10.2-py3-none-macosx_10_14_x86_64.whl", hash = "sha256:5761cfccc721da2311c3f1213577f0ff1df07bbbbe3fa3a209a256b82cf057e3", size = 68688870, upload-time = "2026-01-29T12:26:48.619Z" },+ { url = "https://files.pythonhosted.org/packages/ce/c8/d99e65ab01c2402fb6bc4f77abef7244f7d5fb2f2e6d5b0abdf71bb2e4fc/pyqt6_qt6-6.10.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:6dda853a8db1b8d1a2ddbbe76cc6c3aa86614cad14056bd3c0435d8feea73b2d", size = 62512013, upload-time = "2026-01-29T12:27:24.642Z" },+ { url = "https://files.pythonhosted.org/packages/d5/fe/01fd9b9d2ca139ef61582f2e2da249fa169229144294c1bb27db59ad8420/pyqt6_qt6-6.10.2-py3-none-manylinux_2_34_x86_64.whl", hash = "sha256:19c10b5f0806e9f9bac2c9759bd5d7d19a78967f330fd60a2db409177fa76e49", size = 84028760, upload-time = "2026-01-29T12:28:03.267Z" },+ { url = "https://files.pythonhosted.org/packages/f4/20/a0d027ebb267d3afaf319d94efe1ff4d667004ee83b96701329a4d11fb95/pyqt6_qt6-6.10.2-py3-none-manylinux_2_39_aarch64.whl", hash = "sha256:2e60d616861ca4565cd295418d605975aa2dc407ba4b94c1586a70c92e9cb052", size = 83063975, upload-time = "2026-01-29T12:28:48.928Z" },+ { url = "https://files.pythonhosted.org/packages/06/8e/595f215876d507417cc8565e05519916d3b0b76baedea6a1e4e5105633fc/pyqt6_qt6-6.10.2-py3-none-win_amd64.whl", hash = "sha256:c4b7f7d66cc58bddf1bc1ca28dfcf7a45f58cfcb11d81d13a0510409dd4957ac", size = 78433821, upload-time = "2026-01-29T12:29:35.493Z" },+ { url = "https://files.pythonhosted.org/packages/50/5f/2196e2b536217b87cb3d2ce13ef8f7607d08b02f1990a4bd84a88d293a3c/pyqt6_qt6-6.10.2-py3-none-win_arm64.whl", hash = "sha256:7164a6f0c1335358a3026df9865c8f75395b01f60f0dcd2f66c029ec16fc83d2", size = 58354426, upload-time = "2026-01-29T12:30:02.95Z" },][[package]]name = "pyqt6-sip"-version = "13.10.2"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/2f/4a/96daf6c2e4f689faae9bd8cebb52754e76522c58a6af9b5ec86a2e8ec8b4/pyqt6_sip-13.10.2.tar.gz", hash = "sha256:464ad156bf526500ce6bd05cac7a82280af6309974d816739b4a9a627156fafe", size = 92548 }-wheels = [- { url = "https://files.pythonhosted.org/packages/75/9c/ea9ba7786f471ce025dff71653eec4a6c067d24d36d28cced457dd31314c/pyqt6_sip-13.10.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1a6c2f168773af9e6c7ef5e52907f16297d4efd346e4c958eda54ea9135be18e", size = 110707 },- { url = "https://files.pythonhosted.org/packages/d6/00/984a94f14ba378c802a8e304803bb6dc6961cd9f24befa1bf3987731f0c3/pyqt6_sip-13.10.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b1d3cc9015a1bd8c8d3e86a009591e897d4d46b0c514aede7d2970a2208749cd", size = 317301 },- { url = "https://files.pythonhosted.org/packages/0d/b1/c3b433ebcee2503571d71be025de5dab4489d7153007fd5ae79c543eeedb/pyqt6_sip-13.10.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:ddd578a8d975bfb5fef83751829bf09a97a1355fa1de098e4fb4d1b74ee872fc", size = 294277 },- { url = "https://files.pythonhosted.org/packages/24/96/4e909f0a4f7a9ad0076a0e200c10f96a5a09492efb683f3d66c885f9aba4/pyqt6_sip-13.10.2-cp311-cp311-win_amd64.whl", hash = "sha256:061d4a2eb60a603d8be7db6c7f27eb29d9cea97a09aa4533edc1662091ce4f03", size = 53418 },- { url = "https://files.pythonhosted.org/packages/37/96/153c418d8c167fc56f2e62372b8862d577f3ece41b24c5205a05b0c2b0cd/pyqt6_sip-13.10.2-cp311-cp311-win_arm64.whl", hash = "sha256:45ac06f0380b7aa4fcffd89f9e8c00d1b575dc700c603446a9774fda2dcfc0de", size = 44969 },- { url = "https://files.pythonhosted.org/packages/22/5b/1240017e0d59575289ba52b58fd7f95e7ddf0ed2ede95f3f7e2dc845d337/pyqt6_sip-13.10.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:83e6a56d3e715f748557460600ec342cbd77af89ec89c4f2a68b185fa14ea46c", size = 112199 },- { url = "https://files.pythonhosted.org/packages/51/11/1fc3bae02a12a3ac8354aa579b56206286e8b5ca9586677b1058c81c2f74/pyqt6_sip-13.10.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ccf197f8fa410e076936bee28ad9abadb450931d5be5625446fd20e0d8b27a6", size = 322757 },- { url = "https://files.pythonhosted.org/packages/21/40/de9491213f480a27199690616959a17a0f234962b86aa1dd4ca2584e922d/pyqt6_sip-13.10.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:37af463dcce39285e686d49523d376994d8a2508b9acccb7616c4b117c9c4ed7", size = 304251 },- { url = "https://files.pythonhosted.org/packages/02/21/cc80e03f1052408c62c341e9fe9b81454c94184f4bd8a95d29d2ec86df92/pyqt6_sip-13.10.2-cp312-cp312-win_amd64.whl", hash = "sha256:c7b34a495b92790c70eae690d9e816b53d3b625b45eeed6ae2c0fe24075a237e", size = 53519 },- { url = "https://files.pythonhosted.org/packages/77/cf/53bd0863252b260a502659cb3124d9c9fe38047df9360e529b437b4ac890/pyqt6_sip-13.10.2-cp312-cp312-win_arm64.whl", hash = "sha256:c80cc059d772c632f5319632f183e7578cd0976b9498682833035b18a3483e92", size = 45349 },- { url = "https://files.pythonhosted.org/packages/a1/1e/979ea64c98ca26979d8ce11e9a36579e17d22a71f51d7366d6eec3c82c13/pyqt6_sip-13.10.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8b5d06a0eac36038fa8734657d99b5fe92263ae7a0cd0a67be6acfe220a063e1", size = 112227 },- { url = "https://files.pythonhosted.org/packages/d9/21/84c230048e3bfef4a9209d16e56dcd2ae10590d03a31556ae8b5f1dcc724/pyqt6_sip-13.10.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad376a6078da37b049fdf9d6637d71b52727e65c4496a80b753ddc8d27526aca", size = 322920 },- { url = "https://files.pythonhosted.org/packages/b0/1e/c6a28a142f14e735088534cc92951c3f48cccd77cdd4f3b10d7996be420f/pyqt6_sip-13.10.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:3dde8024d055f496eba7d44061c5a1ba4eb72fc95e5a9d7a0dbc908317e0888b", size = 303833 },- { url = "https://files.pythonhosted.org/packages/89/63/e5adf350c1c3123d4865c013f164c5265512fa79f09ad464fb2fdf9f9e61/pyqt6_sip-13.10.2-cp313-cp313-win_amd64.whl", hash = "sha256:0b097eb58b4df936c4a2a88a2f367c8bb5c20ff049a45a7917ad75d698e3b277", size = 53527 },- { url = "https://files.pythonhosted.org/packages/58/74/2df4195306d050fbf4963fb5636108a66e5afa6dc05fd9e81e51ec96c384/pyqt6_sip-13.10.2-cp313-cp313-win_arm64.whl", hash = "sha256:cc6a1dfdf324efaac6e7b890a608385205e652845c62130de919fd73a6326244", size = 45373 },- { url = "https://files.pythonhosted.org/packages/23/57/74b4eb7a51b9133958daa8409b55de95e44feb694d4e2e3eba81a070ca20/pyqt6_sip-13.10.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8a76a06a8e5c5b1f17a3f6f3c834ca324877e07b960b18b8b9bbfd9c536ec658", size = 112354 },- { url = "https://files.pythonhosted.org/packages/f2/cb/fdef02e0d6ee8443a9683a43650d61c6474b634b6ae6e1c6f097da6310bf/pyqt6_sip-13.10.2-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9128d770a611200529468397d710bc972f1dcfe12bfcbb09a3ccddcd4d54fa5b", size = 323488 },- { url = "https://files.pythonhosted.org/packages/8c/5b/8ede8d6234c3ea884cbd097d7d47ff9910fb114efe041af62b4453acd23b/pyqt6_sip-13.10.2-cp314-cp314-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:d820a0fae7315932c08f27dc0a7e33e0f50fe351001601a8eb9cf6f22b04562e", size = 303881 },- { url = "https://files.pythonhosted.org/packages/be/44/b5e78b072d1594643b0f1ff348f2bf54d4adb5a3f9b9f0989c54e33238d6/pyqt6_sip-13.10.2-cp314-cp314-win_amd64.whl", hash = "sha256:3213bb6e102d3842a3bb7e59d5f6e55f176c80880ff0b39d0dac0cfe58313fb3", size = 55098 },- { url = "https://files.pythonhosted.org/packages/e2/91/357e9fcef5d830c3d50503d35e0357818aca3540f78748cc214dfa015d00/pyqt6_sip-13.10.2-cp314-cp314-win_arm64.whl", hash = "sha256:ce33ff1f94960ad4b08035e39fa0c3c9a67070bec39ffe3e435c792721504726", size = 46088 },+version = "13.11.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/e3/7d/d2916048e2e3960f68cb4e93907639844f7b8ff95897dcc98553776ccdfc/pyqt6_sip-13.11.0.tar.gz", hash = "sha256:d463af37738bda1856c9ef513e5620a37b7a005e9d589c986c3304db4a8a14d3", size = 92509, upload-time = "2026-01-13T16:01:32.16Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/4a/41/1c2097aad646f7ef6be9cfd2fd4814ad6bbdba7d53a622ad56e00f88dc72/pyqt6_sip-13.11.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e329ccc3a6502e2b774ef62ab843ac8b3f32191324e8230e6dde78c1c0df5a8", size = 110804, upload-time = "2026-01-13T16:01:02.527Z" },+ { url = "https://files.pythonhosted.org/packages/e0/d3/51143a254a7c9e9650c3eedfc35b967cdcd180a289c6fa2a937c57fe405a/pyqt6_sip-13.11.0-cp311-cp311-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:364424dacdee9e0a2a723646b5608139629ad9bde318dd755d86f5e0ba123c79", size = 291442, upload-time = "2026-01-13T16:01:05.424Z" },+ { url = "https://files.pythonhosted.org/packages/0c/5c/d62e0ded4fdd5abf6a3085a65aa229c863b334758555af1f7b79af9bc003/pyqt6_sip-13.11.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:132ee69d935c14bb4ced2a811ef333200c7aa50324bd7caadefd7d5874495225", size = 317793, upload-time = "2026-01-13T16:01:04.183Z" },+ { url = "https://files.pythonhosted.org/packages/c0/d4/34f3fb522323a5336e31a51ab7ae3103ebc0c8e741bff9630f29480cdca2/pyqt6_sip-13.11.0-cp311-cp311-win_amd64.whl", hash = "sha256:341e52e702d41872515794dea6265ee56b8625c9d3c74ea0468124f0bd675f8b", size = 54101, upload-time = "2026-01-13T16:01:06.504Z" },+ { url = "https://files.pythonhosted.org/packages/a9/a1/37109ec33ead4b9cc62294b48a1ba2b4899cb0d009eb1763d61e3a89ab21/pyqt6_sip-13.11.0-cp311-cp311-win_arm64.whl", hash = "sha256:489fdd0910f8c1d5d40255b4cd7b45f4a4549f9a599512bc6b2cc8d384e28852", size = 48359, upload-time = "2026-01-13T16:01:07.732Z" },+ { url = "https://files.pythonhosted.org/packages/53/a6/0e4d8fa7d6deb750bd0fdf89024e39c71fb127efb5eeedfab6830ad6679a/pyqt6_sip-13.11.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:6b3267cd93b7f4da6fdf9a6a26f3baed8faae06e5cdd76235f2acc2116c40a54", size = 112367, upload-time = "2026-01-13T16:01:09.08Z" },+ { url = "https://files.pythonhosted.org/packages/66/e6/25dc20a03c46000e8b93aaf79347227926b67959283e5aab797daa7f64d8/pyqt6_sip-13.11.0-cp312-cp312-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c30248d9bbe54c46a78e5d549da50295ecd6584b965597f751e272f000fb8527", size = 301150, upload-time = "2026-01-13T16:01:12.385Z" },+ { url = "https://files.pythonhosted.org/packages/11/9f/e850cd350aade789660cafba38c00777e686040c06b8cd0b45339b80fcba/pyqt6_sip-13.11.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c367b53a91e575ef66c1375f899713bdaf0a8b2c64b95ac226e9644854a4984", size = 323303, upload-time = "2026-01-13T16:01:10.736Z" },+ { url = "https://files.pythonhosted.org/packages/77/26/5261d62108f7579407230f8c1d4dda43c18b5600ce70bf3becb2f997d5cc/pyqt6_sip-13.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:077958105c2ea2f62be2f1a7611ff8bd44cb52fb5ea8fc8c59ea949144acb7b5", size = 53461, upload-time = "2026-01-13T16:01:13.875Z" },+ { url = "https://files.pythonhosted.org/packages/46/80/6c88b97eda309d6babb7292200bf51165dc06d0204d891b7bf1fb17a8ed0/pyqt6_sip-13.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:52812471619d3d3750b940d7d124cd0954107656924921ac177e098ba36362fb", size = 48650, upload-time = "2026-01-13T16:01:14.897Z" },+ { url = "https://files.pythonhosted.org/packages/df/a0/46abcae4fce175a326185460a02c13ab81332bca7dd55c1e853ba6aee71e/pyqt6_sip-13.11.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:929716eebde1a64ffdb6b1715db6a22aefd5634d6df84858c7deb5e85be84fdf", size = 112353, upload-time = "2026-01-13T16:01:16.152Z" },+ { url = "https://files.pythonhosted.org/packages/0e/38/27c3aa3f153fcd83a0765fedf8e44a1136f189a322bcc9c494c5b3793cd7/pyqt6_sip-13.11.0-cp313-cp313-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a75144e8a0bcf9d1a9069011890401748af353749f1de1b6a314b880781edf9d", size = 301497, upload-time = "2026-01-13T16:01:20.531Z" },+ { url = "https://files.pythonhosted.org/packages/6f/ac/1053ffce45e4174f0a8174557b88537aa82bf96ba03c7dd208c59de36f69/pyqt6_sip-13.11.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8082b5f57ffad5dddf5efcf0ef5eaf94841395aa4e7c374c79ef24cf49b0f0ce", size = 323498, upload-time = "2026-01-13T16:01:17.859Z" },+ { url = "https://files.pythonhosted.org/packages/40/d3/447b30d1f00cc50ad9e5c53b2e920068606b16857da83f8036b390c79fad/pyqt6_sip-13.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:8d49b5bf3d8d36cd7db93ddc54cd09dbba96a3fd926e445ef75499b41e47b5a3", size = 53469, upload-time = "2026-01-13T16:01:21.762Z" },+ { url = "https://files.pythonhosted.org/packages/92/67/77e6fafcabd01c0a11166ab7464509896f137929f82c4f2e03aea1bf41b3/pyqt6_sip-13.11.0-cp313-cp313-win_arm64.whl", hash = "sha256:293eac1b53c66c54b03266cc30015ec77454af679043a4f188b9bb80a9656996", size = 48643, upload-time = "2026-01-13T16:01:22.669Z" },+ { url = "https://files.pythonhosted.org/packages/ff/28/a5178c8e005bafbf9c0fd507f45a3eef619ab582811414a0a461ee75994f/pyqt6_sip-13.11.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:4dc9c4df24af0571423c3e85b5c008bad42ed48558eef80fbc3e5d30274c5abb", size = 112431, upload-time = "2026-01-13T16:01:23.832Z" },+ { url = "https://files.pythonhosted.org/packages/13/3c/02770b02b5a05779e26bd02c202c2fd32aa38e225d01f14c06908e33738c/pyqt6_sip-13.11.0-cp314-cp314-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c974d5a193f32e55e746e9b63138503163ac63500dbb1fd67233d8a8d71369bd", size = 301236, upload-time = "2026-01-13T16:01:28.733Z" },+ { url = "https://files.pythonhosted.org/packages/40/47/5af493a698cc520581ca1000b4ab09b8182992053ffe2478062dde5e4671/pyqt6_sip-13.11.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4284540ffccd8349763ddce3518264dde62f20556720d4061b9c895e09011ca0", size = 323919, upload-time = "2026-01-13T16:01:25.122Z" },+ { url = "https://files.pythonhosted.org/packages/b7/2d/64b26e21183a7ff180105871dd5983a8da539d8768921728268dc6d0a73d/pyqt6_sip-13.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:9bd81cb351640abc803ea2fe7262b5adea28615c9b96fd103d1b6f3459937211", size = 55078, upload-time = "2026-01-13T16:01:29.853Z" },+ { url = "https://files.pythonhosted.org/packages/7e/36/23f699fa8b1c3fcc312ecd12661a1df6057d92e16d4def2399b59cf7bf22/pyqt6_sip-13.11.0-cp314-cp314-win_arm64.whl", hash = "sha256:cd95ec98f8edb15bcea832b8657809f69d758bc4151cc6fd7790c0181949e45f", size = 49465, upload-time = "2026-01-13T16:01:31.174Z" },][[package]]name = "pytest"-version = "9.0.1"+version = "9.0.2"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "colorama", marker = "sys_platform == 'win32'" },@@ -1738,9 +1691,22 @@ dependencies = [{ name = "pluggy" },{ name = "pygments" },]-sdist = { url = "https://files.pythonhosted.org/packages/07/56/f013048ac4bc4c1d9be45afd4ab209ea62822fb1598f40687e6bf45dcea4/pytest-9.0.1.tar.gz", hash = "sha256:3e9c069ea73583e255c3b21cf46b8d3c56f6e3a1a8f6da94ccb0fcf57b9d73c8", size = 1564125 }+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },+]++[[package]]+name = "pytest-asyncio"+version = "1.3.0"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "pytest" },+ { name = "typing-extensions", marker = "python_full_version < '3.13'" },+]+sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/0b/8b/6300fb80f858cda1c51ffa17075df5d846757081d11ab4aa35cef9e6258b/pytest-9.0.1-py3-none-any.whl", hash = "sha256:67be0030d194df2dfa7b556f2e56fb3c3315bd5c8822c6951162b92b32ce7dad", size = 373668 },+ { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },][[package]]@@ -1750,82 +1716,82 @@ source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "six" },]-sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 }+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 },+ { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },][[package]]name = "pytz"version = "2025.2"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884 }+sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884, upload-time = "2025-03-25T02:25:00.538Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225 },+ { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload-time = "2025-03-25T02:24:58.468Z" },][[package]]name = "pywin32-ctypes"version = "0.2.3"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471 }+sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471, upload-time = "2024-08-14T10:15:34.626Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756 },+ { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" },][[package]]name = "pyyaml"version = "6.0.3"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960 }-wheels = [- { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826 },- { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577 },- { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556 },- { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114 },- { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638 },- { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463 },- { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986 },- { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543 },- { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763 },- { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063 },- { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973 },- { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116 },- { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011 },- { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870 },- { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089 },- { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181 },- { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658 },- { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003 },- { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344 },- { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669 },- { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252 },- { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081 },- { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159 },- { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626 },- { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613 },- { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115 },- { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427 },- { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090 },- { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246 },- { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814 },- { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809 },- { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454 },- { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355 },- { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175 },- { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228 },- { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194 },- { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429 },- { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912 },- { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108 },- { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641 },- { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901 },- { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132 },- { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261 },- { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272 },- { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923 },- { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062 },- { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341 },+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },+ { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },+ { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },+ { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },+ { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },+ { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },+ { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },+ { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },+ { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },+ { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },+ { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },+ { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },+ { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },+ { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },+ { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },+ { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },+ { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },+ { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },+ { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },+ { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },+ { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },+ { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },+ { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },+ { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },+ { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },+ { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },+ { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },+ { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },+ { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },+ { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },+ { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },+ { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },+ { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },+ { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },+ { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },+ { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },+ { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },+ { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },+ { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },+ { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },+ { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },+ { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },+ { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },+ { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },+ { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },+ { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },+ { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },][[package]]@@ -1838,27 +1804,52 @@ dependencies = [{ name = "idna" },{ name = "urllib3" },]-sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517 }+sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738 },+ { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },][[package]]name = "rich"-version = "14.2.0"+version = "14.3.2"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "markdown-it-py" },{ name = "pygments" },]-sdist = { url = "https://files.pythonhosted.org/packages/fb/d2/8920e102050a0de7bfabeb4c4614a49248cf8d5d7a8d01885fbb24dc767a/rich-14.2.0.tar.gz", hash = "sha256:73ff50c7c0c1c77c8243079283f4edb376f0f6442433aecb8ce7e6d0b92d1fe4", size = 219990 }+sdist = { url = "https://files.pythonhosted.org/packages/74/99/a4cab2acbb884f80e558b0771e97e21e939c5dfb460f488d19df485e8298/rich-14.3.2.tar.gz", hash = "sha256:e712f11c1a562a11843306f5ed999475f09ac31ffb64281f73ab29ffdda8b3b8", size = 230143, upload-time = "2026-02-01T16:20:47.908Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393 },+ { url = "https://files.pythonhosted.org/packages/ef/45/615f5babd880b4bd7d405cc0dc348234c5ffb6ed1ea33e152ede08b2072d/rich-14.3.2-py3-none-any.whl", hash = "sha256:08e67c3e90884651da3239ea668222d19bea7b589149d8014a21c633420dbb69", size = 309963, upload-time = "2026-02-01T16:20:46.078Z" },+]++[[package]]+name = "ruff"+version = "0.15.1"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/04/dc/4e6ac71b511b141cf626357a3946679abeba4cf67bc7cc5a17920f31e10d/ruff-0.15.1.tar.gz", hash = "sha256:c590fe13fb57c97141ae975c03a1aedb3d3156030cabd740d6ff0b0d601e203f", size = 4540855, upload-time = "2026-02-12T23:09:09.998Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/23/bf/e6e4324238c17f9d9120a9d60aa99a7daaa21204c07fcd84e2ef03bb5fd1/ruff-0.15.1-py3-none-linux_armv6l.whl", hash = "sha256:b101ed7cf4615bda6ffe65bdb59f964e9f4a0d3f85cbf0e54f0ab76d7b90228a", size = 10367819, upload-time = "2026-02-12T23:09:03.598Z" },+ { url = "https://files.pythonhosted.org/packages/b3/ea/c8f89d32e7912269d38c58f3649e453ac32c528f93bb7f4219258be2e7ed/ruff-0.15.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:939c995e9277e63ea632cc8d3fae17aa758526f49a9a850d2e7e758bfef46602", size = 10798618, upload-time = "2026-02-12T23:09:22.928Z" },+ { url = "https://files.pythonhosted.org/packages/5e/0f/1d0d88bc862624247d82c20c10d4c0f6bb2f346559d8af281674cf327f15/ruff-0.15.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1d83466455fdefe60b8d9c8df81d3c1bbb2115cede53549d3b522ce2bc703899", size = 10148518, upload-time = "2026-02-12T23:08:58.339Z" },+ { url = "https://files.pythonhosted.org/packages/f5/c8/291c49cefaa4a9248e986256df2ade7add79388fe179e0691be06fae6f37/ruff-0.15.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9457e3c3291024866222b96108ab2d8265b477e5b1534c7ddb1810904858d16", size = 10518811, upload-time = "2026-02-12T23:09:31.865Z" },+ { url = "https://files.pythonhosted.org/packages/c3/1a/f5707440e5ae43ffa5365cac8bbb91e9665f4a883f560893829cf16a606b/ruff-0.15.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:92c92b003e9d4f7fbd33b1867bb15a1b785b1735069108dfc23821ba045b29bc", size = 10196169, upload-time = "2026-02-12T23:09:17.306Z" },+ { url = "https://files.pythonhosted.org/packages/2a/ff/26ddc8c4da04c8fd3ee65a89c9fb99eaa5c30394269d424461467be2271f/ruff-0.15.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fe5c41ab43e3a06778844c586251eb5a510f67125427625f9eb2b9526535779", size = 10990491, upload-time = "2026-02-12T23:09:25.503Z" },+ { url = "https://files.pythonhosted.org/packages/fc/00/50920cb385b89413f7cdb4bb9bc8fc59c1b0f30028d8bccc294189a54955/ruff-0.15.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66a6dd6df4d80dc382c6484f8ce1bcceb55c32e9f27a8b94c32f6c7331bf14fb", size = 11843280, upload-time = "2026-02-12T23:09:19.88Z" },+ { url = "https://files.pythonhosted.org/packages/5d/6d/2f5cad8380caf5632a15460c323ae326f1e1a2b5b90a6ee7519017a017ca/ruff-0.15.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6a4a42cbb8af0bda9bcd7606b064d7c0bc311a88d141d02f78920be6acb5aa83", size = 11274336, upload-time = "2026-02-12T23:09:14.907Z" },+ { url = "https://files.pythonhosted.org/packages/a3/1d/5f56cae1d6c40b8a318513599b35ea4b075d7dc1cd1d04449578c29d1d75/ruff-0.15.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ab064052c31dddada35079901592dfba2e05f5b1e43af3954aafcbc1096a5b2", size = 11137288, upload-time = "2026-02-12T23:09:07.475Z" },+ { url = "https://files.pythonhosted.org/packages/cd/20/6f8d7d8f768c93b0382b33b9306b3b999918816da46537d5a61635514635/ruff-0.15.1-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:5631c940fe9fe91f817a4c2ea4e81f47bee3ca4aa646134a24374f3c19ad9454", size = 11070681, upload-time = "2026-02-12T23:08:55.43Z" },+ { url = "https://files.pythonhosted.org/packages/9a/67/d640ac76069f64cdea59dba02af2e00b1fa30e2103c7f8d049c0cff4cafd/ruff-0.15.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:68138a4ba184b4691ccdc39f7795c66b3c68160c586519e7e8444cf5a53e1b4c", size = 10486401, upload-time = "2026-02-12T23:09:27.927Z" },+ { url = "https://files.pythonhosted.org/packages/65/3d/e1429f64a3ff89297497916b88c32a5cc88eeca7e9c787072d0e7f1d3e1e/ruff-0.15.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:518f9af03bfc33c03bdb4cb63fabc935341bb7f54af500f92ac309ecfbba6330", size = 10197452, upload-time = "2026-02-12T23:09:12.147Z" },+ { url = "https://files.pythonhosted.org/packages/78/83/e2c3bade17dad63bf1e1c2ffaf11490603b760be149e1419b07049b36ef2/ruff-0.15.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:da79f4d6a826caaea95de0237a67e33b81e6ec2e25fc7e1993a4015dffca7c61", size = 10693900, upload-time = "2026-02-12T23:09:34.418Z" },+ { url = "https://files.pythonhosted.org/packages/a1/27/fdc0e11a813e6338e0706e8b39bb7a1d61ea5b36873b351acee7e524a72a/ruff-0.15.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3dd86dccb83cd7d4dcfac303ffc277e6048600dfc22e38158afa208e8bf94a1f", size = 11227302, upload-time = "2026-02-12T23:09:36.536Z" },+ { url = "https://files.pythonhosted.org/packages/f6/58/ac864a75067dcbd3b95be5ab4eb2b601d7fbc3d3d736a27e391a4f92a5c1/ruff-0.15.1-py3-none-win32.whl", hash = "sha256:660975d9cb49b5d5278b12b03bb9951d554543a90b74ed5d366b20e2c57c2098", size = 10462555, upload-time = "2026-02-12T23:09:29.899Z" },+ { url = "https://files.pythonhosted.org/packages/e0/5e/d4ccc8a27ecdb78116feac4935dfc39d1304536f4296168f91ed3ec00cd2/ruff-0.15.1-py3-none-win_amd64.whl", hash = "sha256:c820fef9dd5d4172a6570e5721704a96c6679b80cf7be41659ed439653f62336", size = 11599956, upload-time = "2026-02-12T23:09:01.157Z" },+ { url = "https://files.pythonhosted.org/packages/2a/07/5bda6a85b220c64c65686bc85bd0bbb23b29c62b3a9f9433fa55f17cda93/ruff-0.15.1-py3-none-win_arm64.whl", hash = "sha256:5ff7d5f0f88567850f45081fac8f4ec212be8d0b963e385c3f7d0d2eb4899416", size = 10874604, upload-time = "2026-02-12T23:09:05.515Z" },][[package]]name = "scikit-learn"-version = "1.7.2"+version = "1.8.0"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "joblib" },@@ -1866,33 +1857,44 @@ dependencies = [{ name = "scipy" },{ name = "threadpoolctl" },]-sdist = { url = "https://files.pythonhosted.org/packages/98/c2/a7855e41c9d285dfe86dc50b250978105dce513d6e459ea66a6aeb0e1e0c/scikit_learn-1.7.2.tar.gz", hash = "sha256:20e9e49ecd130598f1ca38a1d85090e1a600147b9c02fa6f15d69cb53d968fda", size = 7193136 }-wheels = [- { url = "https://files.pythonhosted.org/packages/43/83/564e141eef908a5863a54da8ca342a137f45a0bfb71d1d79704c9894c9d1/scikit_learn-1.7.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c7509693451651cd7361d30ce4e86a1347493554f172b1c72a39300fa2aea79e", size = 9331967 },- { url = "https://files.pythonhosted.org/packages/18/d6/ba863a4171ac9d7314c4d3fc251f015704a2caeee41ced89f321c049ed83/scikit_learn-1.7.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:0486c8f827c2e7b64837c731c8feff72c0bd2b998067a8a9cbc10643c31f0fe1", size = 8648645 },- { url = "https://files.pythonhosted.org/packages/ef/0e/97dbca66347b8cf0ea8b529e6bb9367e337ba2e8be0ef5c1a545232abfde/scikit_learn-1.7.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:89877e19a80c7b11a2891a27c21c4894fb18e2c2e077815bcade10d34287b20d", size = 9715424 },- { url = "https://files.pythonhosted.org/packages/f7/32/1f3b22e3207e1d2c883a7e09abb956362e7d1bd2f14458c7de258a26ac15/scikit_learn-1.7.2-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8da8bf89d4d79aaec192d2bda62f9b56ae4e5b4ef93b6a56b5de4977e375c1f1", size = 9509234 },- { url = "https://files.pythonhosted.org/packages/9f/71/34ddbd21f1da67c7a768146968b4d0220ee6831e4bcbad3e03dd3eae88b6/scikit_learn-1.7.2-cp311-cp311-win_amd64.whl", hash = "sha256:9b7ed8d58725030568523e937c43e56bc01cadb478fc43c042a9aca1dacb3ba1", size = 8894244 },- { url = "https://files.pythonhosted.org/packages/a7/aa/3996e2196075689afb9fce0410ebdb4a09099d7964d061d7213700204409/scikit_learn-1.7.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8d91a97fa2b706943822398ab943cde71858a50245e31bc71dba62aab1d60a96", size = 9259818 },- { url = "https://files.pythonhosted.org/packages/43/5d/779320063e88af9c4a7c2cf463ff11c21ac9c8bd730c4a294b0000b666c9/scikit_learn-1.7.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:acbc0f5fd2edd3432a22c69bed78e837c70cf896cd7993d71d51ba6708507476", size = 8636997 },- { url = "https://files.pythonhosted.org/packages/5c/d0/0c577d9325b05594fdd33aa970bf53fb673f051a45496842caee13cfd7fe/scikit_learn-1.7.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e5bf3d930aee75a65478df91ac1225ff89cd28e9ac7bd1196853a9229b6adb0b", size = 9478381 },- { url = "https://files.pythonhosted.org/packages/82/70/8bf44b933837ba8494ca0fc9a9ab60f1c13b062ad0197f60a56e2fc4c43e/scikit_learn-1.7.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4d6e9deed1a47aca9fe2f267ab8e8fe82ee20b4526b2c0cd9e135cea10feb44", size = 9300296 },- { url = "https://files.pythonhosted.org/packages/c6/99/ed35197a158f1fdc2fe7c3680e9c70d0128f662e1fee4ed495f4b5e13db0/scikit_learn-1.7.2-cp312-cp312-win_amd64.whl", hash = "sha256:6088aa475f0785e01bcf8529f55280a3d7d298679f50c0bb70a2364a82d0b290", size = 8731256 },- { url = "https://files.pythonhosted.org/packages/ae/93/a3038cb0293037fd335f77f31fe053b89c72f17b1c8908c576c29d953e84/scikit_learn-1.7.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0b7dacaa05e5d76759fb071558a8b5130f4845166d88654a0f9bdf3eb57851b7", size = 9212382 },- { url = "https://files.pythonhosted.org/packages/40/dd/9a88879b0c1104259136146e4742026b52df8540c39fec21a6383f8292c7/scikit_learn-1.7.2-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:abebbd61ad9e1deed54cca45caea8ad5f79e1b93173dece40bb8e0c658dbe6fe", size = 8592042 },- { url = "https://files.pythonhosted.org/packages/46/af/c5e286471b7d10871b811b72ae794ac5fe2989c0a2df07f0ec723030f5f5/scikit_learn-1.7.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:502c18e39849c0ea1a5d681af1dbcf15f6cce601aebb657aabbfe84133c1907f", size = 9434180 },- { url = "https://files.pythonhosted.org/packages/f1/fd/df59faa53312d585023b2da27e866524ffb8faf87a68516c23896c718320/scikit_learn-1.7.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a4c328a71785382fe3fe676a9ecf2c86189249beff90bf85e22bdb7efaf9ae0", size = 9283660 },- { url = "https://files.pythonhosted.org/packages/a7/c7/03000262759d7b6f38c836ff9d512f438a70d8a8ddae68ee80de72dcfb63/scikit_learn-1.7.2-cp313-cp313-win_amd64.whl", hash = "sha256:63a9afd6f7b229aad94618c01c252ce9e6fa97918c5ca19c9a17a087d819440c", size = 8702057 },- { url = "https://files.pythonhosted.org/packages/55/87/ef5eb1f267084532c8e4aef98a28b6ffe7425acbfd64b5e2f2e066bc29b3/scikit_learn-1.7.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9acb6c5e867447b4e1390930e3944a005e2cb115922e693c08a323421a6966e8", size = 9558731 },- { url = "https://files.pythonhosted.org/packages/93/f8/6c1e3fc14b10118068d7938878a9f3f4e6d7b74a8ddb1e5bed65159ccda8/scikit_learn-1.7.2-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:2a41e2a0ef45063e654152ec9d8bcfc39f7afce35b08902bfe290c2498a67a6a", size = 9038852 },- { url = "https://files.pythonhosted.org/packages/83/87/066cafc896ee540c34becf95d30375fe5cbe93c3b75a0ee9aa852cd60021/scikit_learn-1.7.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98335fb98509b73385b3ab2bd0639b1f610541d3988ee675c670371d6a87aa7c", size = 9527094 },- { url = "https://files.pythonhosted.org/packages/9c/2b/4903e1ccafa1f6453b1ab78413938c8800633988c838aa0be386cbb33072/scikit_learn-1.7.2-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:191e5550980d45449126e23ed1d5e9e24b2c68329ee1f691a3987476e115e09c", size = 9367436 },- { url = "https://files.pythonhosted.org/packages/b5/aa/8444be3cfb10451617ff9d177b3c190288f4563e6c50ff02728be67ad094/scikit_learn-1.7.2-cp313-cp313t-win_amd64.whl", hash = "sha256:57dc4deb1d3762c75d685507fbd0bc17160144b2f2ba4ccea5dc285ab0d0e973", size = 9275749 },- { url = "https://files.pythonhosted.org/packages/d9/82/dee5acf66837852e8e68df6d8d3a6cb22d3df997b733b032f513d95205b7/scikit_learn-1.7.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fa8f63940e29c82d1e67a45d5297bdebbcb585f5a5a50c4914cc2e852ab77f33", size = 9208906 },- { url = "https://files.pythonhosted.org/packages/3c/30/9029e54e17b87cb7d50d51a5926429c683d5b4c1732f0507a6c3bed9bf65/scikit_learn-1.7.2-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:f95dc55b7902b91331fa4e5845dd5bde0580c9cd9612b1b2791b7e80c3d32615", size = 8627836 },- { url = "https://files.pythonhosted.org/packages/60/18/4a52c635c71b536879f4b971c2cedf32c35ee78f48367885ed8025d1f7ee/scikit_learn-1.7.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9656e4a53e54578ad10a434dc1f993330568cfee176dff07112b8785fb413106", size = 9426236 },- { url = "https://files.pythonhosted.org/packages/99/7e/290362f6ab582128c53445458a5befd471ed1ea37953d5bcf80604619250/scikit_learn-1.7.2-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96dc05a854add0e50d3f47a1ef21a10a595016da5b007c7d9cd9d0bffd1fcc61", size = 9312593 },- { url = "https://files.pythonhosted.org/packages/8e/87/24f541b6d62b1794939ae6422f8023703bbf6900378b2b34e0b4384dfefd/scikit_learn-1.7.2-cp314-cp314-win_amd64.whl", hash = "sha256:bb24510ed3f9f61476181e4db51ce801e2ba37541def12dc9333b946fc7a9cf8", size = 8820007 },+sdist = { url = "https://files.pythonhosted.org/packages/0e/d4/40988bf3b8e34feec1d0e6a051446b1f66225f8529b9309becaeef62b6c4/scikit_learn-1.8.0.tar.gz", hash = "sha256:9bccbb3b40e3de10351f8f5068e105d0f4083b1a65fa07b6634fbc401a6287fd", size = 7335585, upload-time = "2025-12-10T07:08:53.618Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/c9/92/53ea2181da8ac6bf27170191028aee7251f8f841f8d3edbfdcaf2008fde9/scikit_learn-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:146b4d36f800c013d267b29168813f7a03a43ecd2895d04861f1240b564421da", size = 8595835, upload-time = "2025-12-10T07:07:39.385Z" },+ { url = "https://files.pythonhosted.org/packages/01/18/d154dc1638803adf987910cdd07097d9c526663a55666a97c124d09fb96a/scikit_learn-1.8.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:f984ca4b14914e6b4094c5d52a32ea16b49832c03bd17a110f004db3c223e8e1", size = 8080381, upload-time = "2025-12-10T07:07:41.93Z" },+ { url = "https://files.pythonhosted.org/packages/8a/44/226142fcb7b7101e64fdee5f49dbe6288d4c7af8abf593237b70fca080a4/scikit_learn-1.8.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e30adb87f0cc81c7690a84f7932dd66be5bac57cfe16b91cb9151683a4a2d3b", size = 8799632, upload-time = "2025-12-10T07:07:43.899Z" },+ { url = "https://files.pythonhosted.org/packages/36/4d/4a67f30778a45d542bbea5db2dbfa1e9e100bf9ba64aefe34215ba9f11f6/scikit_learn-1.8.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ada8121bcb4dac28d930febc791a69f7cb1673c8495e5eee274190b73a4559c1", size = 9103788, upload-time = "2025-12-10T07:07:45.982Z" },+ { url = "https://files.pythonhosted.org/packages/89/3c/45c352094cfa60050bcbb967b1faf246b22e93cb459f2f907b600f2ceda5/scikit_learn-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:c57b1b610bd1f40ba43970e11ce62821c2e6569e4d74023db19c6b26f246cb3b", size = 8081706, upload-time = "2025-12-10T07:07:48.111Z" },+ { url = "https://files.pythonhosted.org/packages/3d/46/5416595bb395757f754feb20c3d776553a386b661658fb21b7c814e89efe/scikit_learn-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:2838551e011a64e3053ad7618dda9310175f7515f1742fa2d756f7c874c05961", size = 7688451, upload-time = "2025-12-10T07:07:49.873Z" },+ { url = "https://files.pythonhosted.org/packages/90/74/e6a7cc4b820e95cc38cf36cd74d5aa2b42e8ffc2d21fe5a9a9c45c1c7630/scikit_learn-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5fb63362b5a7ddab88e52b6dbb47dac3fd7dafeee740dc6c8d8a446ddedade8e", size = 8548242, upload-time = "2025-12-10T07:07:51.568Z" },+ { url = "https://files.pythonhosted.org/packages/49/d8/9be608c6024d021041c7f0b3928d4749a706f4e2c3832bbede4fb4f58c95/scikit_learn-1.8.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:5025ce924beccb28298246e589c691fe1b8c1c96507e6d27d12c5fadd85bfd76", size = 8079075, upload-time = "2025-12-10T07:07:53.697Z" },+ { url = "https://files.pythonhosted.org/packages/dd/47/f187b4636ff80cc63f21cd40b7b2d177134acaa10f6bb73746130ee8c2e5/scikit_learn-1.8.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4496bb2cf7a43ce1a2d7524a79e40bc5da45cf598dbf9545b7e8316ccba47bb4", size = 8660492, upload-time = "2025-12-10T07:07:55.574Z" },+ { url = "https://files.pythonhosted.org/packages/97/74/b7a304feb2b49df9fafa9382d4d09061a96ee9a9449a7cbea7988dda0828/scikit_learn-1.8.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a0bcfe4d0d14aec44921545fd2af2338c7471de9cb701f1da4c9d85906ab847a", size = 8931904, upload-time = "2025-12-10T07:07:57.666Z" },+ { url = "https://files.pythonhosted.org/packages/9f/c4/0ab22726a04ede56f689476b760f98f8f46607caecff993017ac1b64aa5d/scikit_learn-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:35c007dedb2ffe38fe3ee7d201ebac4a2deccd2408e8621d53067733e3c74809", size = 8019359, upload-time = "2025-12-10T07:07:59.838Z" },+ { url = "https://files.pythonhosted.org/packages/24/90/344a67811cfd561d7335c1b96ca21455e7e472d281c3c279c4d3f2300236/scikit_learn-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:8c497fff237d7b4e07e9ef1a640887fa4fb765647f86fbe00f969ff6280ce2bb", size = 7641898, upload-time = "2025-12-10T07:08:01.36Z" },+ { url = "https://files.pythonhosted.org/packages/03/aa/e22e0768512ce9255eba34775be2e85c2048da73da1193e841707f8f039c/scikit_learn-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0d6ae97234d5d7079dc0040990a6f7aeb97cb7fa7e8945f1999a429b23569e0a", size = 8513770, upload-time = "2025-12-10T07:08:03.251Z" },+ { url = "https://files.pythonhosted.org/packages/58/37/31b83b2594105f61a381fc74ca19e8780ee923be2d496fcd8d2e1147bd99/scikit_learn-1.8.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:edec98c5e7c128328124a029bceb09eda2d526997780fef8d65e9a69eead963e", size = 8044458, upload-time = "2025-12-10T07:08:05.336Z" },+ { url = "https://files.pythonhosted.org/packages/2d/5a/3f1caed8765f33eabb723596666da4ebbf43d11e96550fb18bdec42b467b/scikit_learn-1.8.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:74b66d8689d52ed04c271e1329f0c61635bcaf5b926db9b12d58914cdc01fe57", size = 8610341, upload-time = "2025-12-10T07:08:07.732Z" },+ { url = "https://files.pythonhosted.org/packages/38/cf/06896db3f71c75902a8e9943b444a56e727418f6b4b4a90c98c934f51ed4/scikit_learn-1.8.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8fdf95767f989b0cfedb85f7ed8ca215d4be728031f56ff5a519ee1e3276dc2e", size = 8900022, upload-time = "2025-12-10T07:08:09.862Z" },+ { url = "https://files.pythonhosted.org/packages/1c/f9/9b7563caf3ec8873e17a31401858efab6b39a882daf6c1bfa88879c0aa11/scikit_learn-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:2de443b9373b3b615aec1bb57f9baa6bb3a9bd093f1269ba95c17d870422b271", size = 7989409, upload-time = "2025-12-10T07:08:12.028Z" },+ { url = "https://files.pythonhosted.org/packages/49/bd/1f4001503650e72c4f6009ac0c4413cb17d2d601cef6f71c0453da2732fc/scikit_learn-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:eddde82a035681427cbedded4e6eff5e57fa59216c2e3e90b10b19ab1d0a65c3", size = 7619760, upload-time = "2025-12-10T07:08:13.688Z" },+ { url = "https://files.pythonhosted.org/packages/d2/7d/a630359fc9dcc95496588c8d8e3245cc8fd81980251079bc09c70d41d951/scikit_learn-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:7cc267b6108f0a1499a734167282c00c4ebf61328566b55ef262d48e9849c735", size = 8826045, upload-time = "2025-12-10T07:08:15.215Z" },+ { url = "https://files.pythonhosted.org/packages/cc/56/a0c86f6930cfcd1c7054a2bc417e26960bb88d32444fe7f71d5c2cfae891/scikit_learn-1.8.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:fe1c011a640a9f0791146011dfd3c7d9669785f9fed2b2a5f9e207536cf5c2fd", size = 8420324, upload-time = "2025-12-10T07:08:17.561Z" },+ { url = "https://files.pythonhosted.org/packages/46/1e/05962ea1cebc1cf3876667ecb14c283ef755bf409993c5946ade3b77e303/scikit_learn-1.8.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72358cce49465d140cc4e7792015bb1f0296a9742d5622c67e31399b75468b9e", size = 8680651, upload-time = "2025-12-10T07:08:19.952Z" },+ { url = "https://files.pythonhosted.org/packages/fe/56/a85473cd75f200c9759e3a5f0bcab2d116c92a8a02ee08ccd73b870f8bb4/scikit_learn-1.8.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:80832434a6cc114f5219211eec13dcbc16c2bac0e31ef64c6d346cde3cf054cb", size = 8925045, upload-time = "2025-12-10T07:08:22.11Z" },+ { url = "https://files.pythonhosted.org/packages/cc/b7/64d8cfa896c64435ae57f4917a548d7ac7a44762ff9802f75a79b77cb633/scikit_learn-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ee787491dbfe082d9c3013f01f5991658b0f38aa8177e4cd4bf434c58f551702", size = 8507994, upload-time = "2025-12-10T07:08:23.943Z" },+ { url = "https://files.pythonhosted.org/packages/5e/37/e192ea709551799379958b4c4771ec507347027bb7c942662c7fbeba31cb/scikit_learn-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf97c10a3f5a7543f9b88cbf488d33d175e9146115a451ae34568597ba33dcde", size = 7869518, upload-time = "2025-12-10T07:08:25.71Z" },+ { url = "https://files.pythonhosted.org/packages/24/05/1af2c186174cc92dcab2233f327336058c077d38f6fe2aceb08e6ab4d509/scikit_learn-1.8.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:c22a2da7a198c28dd1a6e1136f19c830beab7fdca5b3e5c8bba8394f8a5c45b3", size = 8528667, upload-time = "2025-12-10T07:08:27.541Z" },+ { url = "https://files.pythonhosted.org/packages/a8/25/01c0af38fe969473fb292bba9dc2b8f9b451f3112ff242c647fee3d0dfe7/scikit_learn-1.8.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:6b595b07a03069a2b1740dc08c2299993850ea81cce4fe19b2421e0c970de6b7", size = 8066524, upload-time = "2025-12-10T07:08:29.822Z" },+ { url = "https://files.pythonhosted.org/packages/be/ce/a0623350aa0b68647333940ee46fe45086c6060ec604874e38e9ab7d8e6c/scikit_learn-1.8.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:29ffc74089f3d5e87dfca4c2c8450f88bdc61b0fc6ed5d267f3988f19a1309f6", size = 8657133, upload-time = "2025-12-10T07:08:31.865Z" },+ { url = "https://files.pythonhosted.org/packages/b8/cb/861b41341d6f1245e6ca80b1c1a8c4dfce43255b03df034429089ca2a2c5/scikit_learn-1.8.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fb65db5d7531bccf3a4f6bec3462223bea71384e2cda41da0f10b7c292b9e7c4", size = 8923223, upload-time = "2025-12-10T07:08:34.166Z" },+ { url = "https://files.pythonhosted.org/packages/76/18/a8def8f91b18cd1ba6e05dbe02540168cb24d47e8dcf69e8d00b7da42a08/scikit_learn-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:56079a99c20d230e873ea40753102102734c5953366972a71d5cb39a32bc40c6", size = 8096518, upload-time = "2025-12-10T07:08:36.339Z" },+ { url = "https://files.pythonhosted.org/packages/d1/77/482076a678458307f0deb44e29891d6022617b2a64c840c725495bee343f/scikit_learn-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:3bad7565bc9cf37ce19a7c0d107742b320c1285df7aab1a6e2d28780df167242", size = 7754546, upload-time = "2025-12-10T07:08:38.128Z" },+ { url = "https://files.pythonhosted.org/packages/2d/d1/ef294ca754826daa043b2a104e59960abfab4cf653891037d19dd5b6f3cf/scikit_learn-1.8.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:4511be56637e46c25721e83d1a9cea9614e7badc7040c4d573d75fbe257d6fd7", size = 8848305, upload-time = "2025-12-10T07:08:41.013Z" },+ { url = "https://files.pythonhosted.org/packages/5b/e2/b1f8b05138ee813b8e1a4149f2f0d289547e60851fd1bb268886915adbda/scikit_learn-1.8.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:a69525355a641bf8ef136a7fa447672fb54fe8d60cab5538d9eb7c6438543fb9", size = 8432257, upload-time = "2025-12-10T07:08:42.873Z" },+ { url = "https://files.pythonhosted.org/packages/26/11/c32b2138a85dcb0c99f6afd13a70a951bfdff8a6ab42d8160522542fb647/scikit_learn-1.8.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c2656924ec73e5939c76ac4c8b026fc203b83d8900362eb2599d8aee80e4880f", size = 8678673, upload-time = "2025-12-10T07:08:45.362Z" },+ { url = "https://files.pythonhosted.org/packages/c7/57/51f2384575bdec454f4fe4e7a919d696c9ebce914590abf3e52d47607ab8/scikit_learn-1.8.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15fc3b5d19cc2be65404786857f2e13c70c83dd4782676dd6814e3b89dc8f5b9", size = 8922467, upload-time = "2025-12-10T07:08:47.408Z" },+ { url = "https://files.pythonhosted.org/packages/35/4d/748c9e2872637a57981a04adc038dacaa16ba8ca887b23e34953f0b3f742/scikit_learn-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:00d6f1d66fbcf4eba6e356e1420d33cc06c70a45bb1363cd6f6a8e4ebbbdece2", size = 8774395, upload-time = "2025-12-10T07:08:49.337Z" },+ { url = "https://files.pythonhosted.org/packages/60/22/d7b2ebe4704a5e50790ba089d5c2ae308ab6bb852719e6c3bd4f04c3a363/scikit_learn-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:f28dd15c6bb0b66ba09728cf09fd8736c304be29409bd8445a080c1280619e8c", size = 8002647, upload-time = "2025-12-10T07:08:51.601Z" },][[package]]@@ -1902,118 +1904,118 @@ source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "numpy" },]-sdist = { url = "https://files.pythonhosted.org/packages/0a/ca/d8ace4f98322d01abcd52d381134344bf7b431eba7ed8b42bdea5a3c2ac9/scipy-1.16.3.tar.gz", hash = "sha256:01e87659402762f43bd2fee13370553a17ada367d42e7487800bf2916535aecb", size = 30597883 }-wheels = [- { url = "https://files.pythonhosted.org/packages/9b/5f/6f37d7439de1455ce9c5a556b8d1db0979f03a796c030bafdf08d35b7bf9/scipy-1.16.3-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:40be6cf99e68b6c4321e9f8782e7d5ff8265af28ef2cd56e9c9b2638fa08ad97", size = 36630881 },- { url = "https://files.pythonhosted.org/packages/7c/89/d70e9f628749b7e4db2aa4cd89735502ff3f08f7b9b27d2e799485987cd9/scipy-1.16.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:8be1ca9170fcb6223cc7c27f4305d680ded114a1567c0bd2bfcbf947d1b17511", size = 28941012 },- { url = "https://files.pythonhosted.org/packages/a8/a8/0e7a9a6872a923505dbdf6bb93451edcac120363131c19013044a1e7cb0c/scipy-1.16.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:bea0a62734d20d67608660f69dcda23e7f90fb4ca20974ab80b6ed40df87a005", size = 20931935 },- { url = "https://files.pythonhosted.org/packages/bd/c7/020fb72bd79ad798e4dbe53938543ecb96b3a9ac3fe274b7189e23e27353/scipy-1.16.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:2a207a6ce9c24f1951241f4693ede2d393f59c07abc159b2cb2be980820e01fb", size = 23534466 },- { url = "https://files.pythonhosted.org/packages/be/a0/668c4609ce6dbf2f948e167836ccaf897f95fb63fa231c87da7558a374cd/scipy-1.16.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:532fb5ad6a87e9e9cd9c959b106b73145a03f04c7d57ea3e6f6bb60b86ab0876", size = 33593618 },- { url = "https://files.pythonhosted.org/packages/ca/6e/8942461cf2636cdae083e3eb72622a7fbbfa5cf559c7d13ab250a5dbdc01/scipy-1.16.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0151a0749efeaaab78711c78422d413c583b8cdd2011a3c1d6c794938ee9fdb2", size = 35899798 },- { url = "https://files.pythonhosted.org/packages/79/e8/d0f33590364cdbd67f28ce79368b373889faa4ee959588beddf6daef9abe/scipy-1.16.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b7180967113560cca57418a7bc719e30366b47959dd845a93206fbed693c867e", size = 36226154 },- { url = "https://files.pythonhosted.org/packages/39/c1/1903de608c0c924a1749c590064e65810f8046e437aba6be365abc4f7557/scipy-1.16.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:deb3841c925eeddb6afc1e4e4a45e418d19ec7b87c5df177695224078e8ec733", size = 38878540 },- { url = "https://files.pythonhosted.org/packages/f1/d0/22ec7036ba0b0a35bccb7f25ab407382ed34af0b111475eb301c16f8a2e5/scipy-1.16.3-cp311-cp311-win_amd64.whl", hash = "sha256:53c3844d527213631e886621df5695d35e4f6a75f620dca412bcd292f6b87d78", size = 38722107 },- { url = "https://files.pythonhosted.org/packages/7b/60/8a00e5a524bb3bf8898db1650d350f50e6cffb9d7a491c561dc9826c7515/scipy-1.16.3-cp311-cp311-win_arm64.whl", hash = "sha256:9452781bd879b14b6f055b26643703551320aa8d79ae064a71df55c00286a184", size = 25506272 },- { url = "https://files.pythonhosted.org/packages/40/41/5bf55c3f386b1643812f3a5674edf74b26184378ef0f3e7c7a09a7e2ca7f/scipy-1.16.3-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:81fc5827606858cf71446a5e98715ba0e11f0dbc83d71c7409d05486592a45d6", size = 36659043 },- { url = "https://files.pythonhosted.org/packages/1e/0f/65582071948cfc45d43e9870bf7ca5f0e0684e165d7c9ef4e50d783073eb/scipy-1.16.3-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:c97176013d404c7346bf57874eaac5187d969293bf40497140b0a2b2b7482e07", size = 28898986 },- { url = "https://files.pythonhosted.org/packages/96/5e/36bf3f0ac298187d1ceadde9051177d6a4fe4d507e8f59067dc9dd39e650/scipy-1.16.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:2b71d93c8a9936046866acebc915e2af2e292b883ed6e2cbe5c34beb094b82d9", size = 20889814 },- { url = "https://files.pythonhosted.org/packages/80/35/178d9d0c35394d5d5211bbff7ac4f2986c5488b59506fef9e1de13ea28d3/scipy-1.16.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:3d4a07a8e785d80289dfe66b7c27d8634a773020742ec7187b85ccc4b0e7b686", size = 23565795 },- { url = "https://files.pythonhosted.org/packages/fa/46/d1146ff536d034d02f83c8afc3c4bab2eddb634624d6529a8512f3afc9da/scipy-1.16.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0553371015692a898e1aa858fed67a3576c34edefa6b7ebdb4e9dde49ce5c203", size = 33349476 },- { url = "https://files.pythonhosted.org/packages/79/2e/415119c9ab3e62249e18c2b082c07aff907a273741b3f8160414b0e9193c/scipy-1.16.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:72d1717fd3b5e6ec747327ce9bda32d5463f472c9dce9f54499e81fbd50245a1", size = 35676692 },- { url = "https://files.pythonhosted.org/packages/27/82/df26e44da78bf8d2aeaf7566082260cfa15955a5a6e96e6a29935b64132f/scipy-1.16.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1fb2472e72e24d1530debe6ae078db70fb1605350c88a3d14bc401d6306dbffe", size = 36019345 },- { url = "https://files.pythonhosted.org/packages/82/31/006cbb4b648ba379a95c87262c2855cd0d09453e500937f78b30f02fa1cd/scipy-1.16.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c5192722cffe15f9329a3948c4b1db789fbb1f05c97899187dcf009b283aea70", size = 38678975 },- { url = "https://files.pythonhosted.org/packages/c2/7f/acbd28c97e990b421af7d6d6cd416358c9c293fc958b8529e0bd5d2a2a19/scipy-1.16.3-cp312-cp312-win_amd64.whl", hash = "sha256:56edc65510d1331dae01ef9b658d428e33ed48b4f77b1d51caf479a0253f96dc", size = 38555926 },- { url = "https://files.pythonhosted.org/packages/ce/69/c5c7807fd007dad4f48e0a5f2153038dc96e8725d3345b9ee31b2b7bed46/scipy-1.16.3-cp312-cp312-win_arm64.whl", hash = "sha256:a8a26c78ef223d3e30920ef759e25625a0ecdd0d60e5a8818b7513c3e5384cf2", size = 25463014 },- { url = "https://files.pythonhosted.org/packages/72/f1/57e8327ab1508272029e27eeef34f2302ffc156b69e7e233e906c2a5c379/scipy-1.16.3-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:d2ec56337675e61b312179a1ad124f5f570c00f920cc75e1000025451b88241c", size = 36617856 },- { url = "https://files.pythonhosted.org/packages/44/13/7e63cfba8a7452eb756306aa2fd9b37a29a323b672b964b4fdeded9a3f21/scipy-1.16.3-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:16b8bc35a4cc24db80a0ec836a9286d0e31b2503cb2fd7ff7fb0e0374a97081d", size = 28874306 },- { url = "https://files.pythonhosted.org/packages/15/65/3a9400efd0228a176e6ec3454b1fa998fbbb5a8defa1672c3f65706987db/scipy-1.16.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:5803c5fadd29de0cf27fa08ccbfe7a9e5d741bf63e4ab1085437266f12460ff9", size = 20865371 },- { url = "https://files.pythonhosted.org/packages/33/d7/eda09adf009a9fb81827194d4dd02d2e4bc752cef16737cc4ef065234031/scipy-1.16.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:b81c27fc41954319a943d43b20e07c40bdcd3ff7cf013f4fb86286faefe546c4", size = 23524877 },- { url = "https://files.pythonhosted.org/packages/7d/6b/3f911e1ebc364cb81320223a3422aab7d26c9c7973109a9cd0f27c64c6c0/scipy-1.16.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0c3b4dd3d9b08dbce0f3440032c52e9e2ab9f96ade2d3943313dfe51a7056959", size = 33342103 },- { url = "https://files.pythonhosted.org/packages/21/f6/4bfb5695d8941e5c570a04d9fcd0d36bce7511b7d78e6e75c8f9791f82d0/scipy-1.16.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7dc1360c06535ea6116a2220f760ae572db9f661aba2d88074fe30ec2aa1ff88", size = 35697297 },- { url = "https://files.pythonhosted.org/packages/04/e1/6496dadbc80d8d896ff72511ecfe2316b50313bfc3ebf07a3f580f08bd8c/scipy-1.16.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:663b8d66a8748051c3ee9c96465fb417509315b99c71550fda2591d7dd634234", size = 36021756 },- { url = "https://files.pythonhosted.org/packages/fe/bd/a8c7799e0136b987bda3e1b23d155bcb31aec68a4a472554df5f0937eef7/scipy-1.16.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eab43fae33a0c39006a88096cd7b4f4ef545ea0447d250d5ac18202d40b6611d", size = 38696566 },- { url = "https://files.pythonhosted.org/packages/cd/01/1204382461fcbfeb05b6161b594f4007e78b6eba9b375382f79153172b4d/scipy-1.16.3-cp313-cp313-win_amd64.whl", hash = "sha256:062246acacbe9f8210de8e751b16fc37458213f124bef161a5a02c7a39284304", size = 38529877 },- { url = "https://files.pythonhosted.org/packages/7f/14/9d9fbcaa1260a94f4bb5b64ba9213ceb5d03cd88841fe9fd1ffd47a45b73/scipy-1.16.3-cp313-cp313-win_arm64.whl", hash = "sha256:50a3dbf286dbc7d84f176f9a1574c705f277cb6565069f88f60db9eafdbe3ee2", size = 25455366 },- { url = "https://files.pythonhosted.org/packages/e2/a3/9ec205bd49f42d45d77f1730dbad9ccf146244c1647605cf834b3a8c4f36/scipy-1.16.3-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:fb4b29f4cf8cc5a8d628bc8d8e26d12d7278cd1f219f22698a378c3d67db5e4b", size = 37027931 },- { url = "https://files.pythonhosted.org/packages/25/06/ca9fd1f3a4589cbd825b1447e5db3a8ebb969c1eaf22c8579bd286f51b6d/scipy-1.16.3-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:8d09d72dc92742988b0e7750bddb8060b0c7079606c0d24a8cc8e9c9c11f9079", size = 29400081 },- { url = "https://files.pythonhosted.org/packages/6a/56/933e68210d92657d93fb0e381683bc0e53a965048d7358ff5fbf9e6a1b17/scipy-1.16.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:03192a35e661470197556de24e7cb1330d84b35b94ead65c46ad6f16f6b28f2a", size = 21391244 },- { url = "https://files.pythonhosted.org/packages/a8/7e/779845db03dc1418e215726329674b40576879b91814568757ff0014ad65/scipy-1.16.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:57d01cb6f85e34f0946b33caa66e892aae072b64b034183f3d87c4025802a119", size = 23929753 },- { url = "https://files.pythonhosted.org/packages/4c/4b/f756cf8161d5365dcdef9e5f460ab226c068211030a175d2fc7f3f41ca64/scipy-1.16.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:96491a6a54e995f00a28a3c3badfff58fd093bf26cd5fb34a2188c8c756a3a2c", size = 33496912 },- { url = "https://files.pythonhosted.org/packages/09/b5/222b1e49a58668f23839ca1542a6322bb095ab8d6590d4f71723869a6c2c/scipy-1.16.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cd13e354df9938598af2be05822c323e97132d5e6306b83a3b4ee6724c6e522e", size = 35802371 },- { url = "https://files.pythonhosted.org/packages/c1/8d/5964ef68bb31829bde27611f8c9deeac13764589fe74a75390242b64ca44/scipy-1.16.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:63d3cdacb8a824a295191a723ee5e4ea7768ca5ca5f2838532d9f2e2b3ce2135", size = 36190477 },- { url = "https://files.pythonhosted.org/packages/ab/f2/b31d75cb9b5fa4dd39a0a931ee9b33e7f6f36f23be5ef560bf72e0f92f32/scipy-1.16.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e7efa2681ea410b10dde31a52b18b0154d66f2485328830e45fdf183af5aefc6", size = 38796678 },- { url = "https://files.pythonhosted.org/packages/b4/1e/b3723d8ff64ab548c38d87055483714fefe6ee20e0189b62352b5e015bb1/scipy-1.16.3-cp313-cp313t-win_amd64.whl", hash = "sha256:2d1ae2cf0c350e7705168ff2429962a89ad90c2d49d1dd300686d8b2a5af22fc", size = 38640178 },- { url = "https://files.pythonhosted.org/packages/8e/f3/d854ff38789aca9b0cc23008d607ced9de4f7ab14fa1ca4329f86b3758ca/scipy-1.16.3-cp313-cp313t-win_arm64.whl", hash = "sha256:0c623a54f7b79dd88ef56da19bc2873afec9673a48f3b85b18e4d402bdd29a5a", size = 25803246 },- { url = "https://files.pythonhosted.org/packages/99/f6/99b10fd70f2d864c1e29a28bbcaa0c6340f9d8518396542d9ea3b4aaae15/scipy-1.16.3-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:875555ce62743e1d54f06cdf22c1e0bc47b91130ac40fe5d783b6dfa114beeb6", size = 36606469 },- { url = "https://files.pythonhosted.org/packages/4d/74/043b54f2319f48ea940dd025779fa28ee360e6b95acb7cd188fad4391c6b/scipy-1.16.3-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:bb61878c18a470021fb515a843dc7a76961a8daceaaaa8bad1332f1bf4b54657", size = 28872043 },- { url = "https://files.pythonhosted.org/packages/4d/e1/24b7e50cc1c4ee6ffbcb1f27fe9f4c8b40e7911675f6d2d20955f41c6348/scipy-1.16.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:f2622206f5559784fa5c4b53a950c3c7c1cf3e84ca1b9c4b6c03f062f289ca26", size = 20862952 },- { url = "https://files.pythonhosted.org/packages/dd/3a/3e8c01a4d742b730df368e063787c6808597ccb38636ed821d10b39ca51b/scipy-1.16.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:7f68154688c515cdb541a31ef8eb66d8cd1050605be9dcd74199cbd22ac739bc", size = 23508512 },- { url = "https://files.pythonhosted.org/packages/1f/60/c45a12b98ad591536bfe5330cb3cfe1850d7570259303563b1721564d458/scipy-1.16.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8b3c820ddb80029fe9f43d61b81d8b488d3ef8ca010d15122b152db77dc94c22", size = 33413639 },- { url = "https://files.pythonhosted.org/packages/71/bc/35957d88645476307e4839712642896689df442f3e53b0fa016ecf8a3357/scipy-1.16.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d3837938ae715fc0fe3c39c0202de3a8853aff22ca66781ddc2ade7554b7e2cc", size = 35704729 },- { url = "https://files.pythonhosted.org/packages/3b/15/89105e659041b1ca11c386e9995aefacd513a78493656e57789f9d9eab61/scipy-1.16.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aadd23f98f9cb069b3bd64ddc900c4d277778242e961751f77a8cb5c4b946fb0", size = 36086251 },- { url = "https://files.pythonhosted.org/packages/1a/87/c0ea673ac9c6cc50b3da2196d860273bc7389aa69b64efa8493bdd25b093/scipy-1.16.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b7c5f1bda1354d6a19bc6af73a649f8285ca63ac6b52e64e658a5a11d4d69800", size = 38716681 },- { url = "https://files.pythonhosted.org/packages/91/06/837893227b043fb9b0d13e4bd7586982d8136cb249ffb3492930dab905b8/scipy-1.16.3-cp314-cp314-win_amd64.whl", hash = "sha256:e5d42a9472e7579e473879a1990327830493a7047506d58d73fc429b84c1d49d", size = 39358423 },- { url = "https://files.pythonhosted.org/packages/95/03/28bce0355e4d34a7c034727505a02d19548549e190bedd13a721e35380b7/scipy-1.16.3-cp314-cp314-win_arm64.whl", hash = "sha256:6020470b9d00245926f2d5bb93b119ca0340f0d564eb6fbaad843eaebf9d690f", size = 26135027 },- { url = "https://files.pythonhosted.org/packages/b2/6f/69f1e2b682efe9de8fe9f91040f0cd32f13cfccba690512ba4c582b0bc29/scipy-1.16.3-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:e1d27cbcb4602680a49d787d90664fa4974063ac9d4134813332a8c53dbe667c", size = 37028379 },- { url = "https://files.pythonhosted.org/packages/7c/2d/e826f31624a5ebbab1cd93d30fd74349914753076ed0593e1d56a98c4fb4/scipy-1.16.3-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:9b9c9c07b6d56a35777a1b4cc8966118fb16cfd8daf6743867d17d36cfad2d40", size = 29400052 },- { url = "https://files.pythonhosted.org/packages/69/27/d24feb80155f41fd1f156bf144e7e049b4e2b9dd06261a242905e3bc7a03/scipy-1.16.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:3a4c460301fb2cffb7f88528f30b3127742cff583603aa7dc964a52c463b385d", size = 21391183 },- { url = "https://files.pythonhosted.org/packages/f8/d3/1b229e433074c5738a24277eca520a2319aac7465eea7310ea6ae0e98ae2/scipy-1.16.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:f667a4542cc8917af1db06366d3f78a5c8e83badd56409f94d1eac8d8d9133fa", size = 23930174 },- { url = "https://files.pythonhosted.org/packages/16/9d/d9e148b0ec680c0f042581a2be79a28a7ab66c0c4946697f9e7553ead337/scipy-1.16.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f379b54b77a597aa7ee5e697df0d66903e41b9c85a6dd7946159e356319158e8", size = 33497852 },- { url = "https://files.pythonhosted.org/packages/2f/22/4e5f7561e4f98b7bea63cf3fd7934bff1e3182e9f1626b089a679914d5c8/scipy-1.16.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4aff59800a3b7f786b70bfd6ab551001cb553244988d7d6b8299cb1ea653b353", size = 35798595 },- { url = "https://files.pythonhosted.org/packages/83/42/6644d714c179429fc7196857866f219fef25238319b650bb32dde7bf7a48/scipy-1.16.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:da7763f55885045036fabcebd80144b757d3db06ab0861415d1c3b7c69042146", size = 36186269 },- { url = "https://files.pythonhosted.org/packages/ac/70/64b4d7ca92f9cf2e6fc6aaa2eecf80bb9b6b985043a9583f32f8177ea122/scipy-1.16.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ffa6eea95283b2b8079b821dc11f50a17d0571c92b43e2b5b12764dc5f9b285d", size = 38802779 },- { url = "https://files.pythonhosted.org/packages/61/82/8d0e39f62764cce5ffd5284131e109f07cf8955aef9ab8ed4e3aa5e30539/scipy-1.16.3-cp314-cp314t-win_amd64.whl", hash = "sha256:d9f48cafc7ce94cf9b15c6bffdc443a81a27bf7075cf2dcd5c8b40f85d10c4e7", size = 39471128 },- { url = "https://files.pythonhosted.org/packages/64/47/a494741db7280eae6dc033510c319e34d42dd41b7ac0c7ead39354d1a2b5/scipy-1.16.3-cp314-cp314t-win_arm64.whl", hash = "sha256:21d9d6b197227a12dcbf9633320a4e34c6b0e51c57268df255a0942983bac562", size = 26464127 },+sdist = { url = "https://files.pythonhosted.org/packages/0a/ca/d8ace4f98322d01abcd52d381134344bf7b431eba7ed8b42bdea5a3c2ac9/scipy-1.16.3.tar.gz", hash = "sha256:01e87659402762f43bd2fee13370553a17ada367d42e7487800bf2916535aecb", size = 30597883, upload-time = "2025-10-28T17:38:54.068Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/9b/5f/6f37d7439de1455ce9c5a556b8d1db0979f03a796c030bafdf08d35b7bf9/scipy-1.16.3-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:40be6cf99e68b6c4321e9f8782e7d5ff8265af28ef2cd56e9c9b2638fa08ad97", size = 36630881, upload-time = "2025-10-28T17:31:47.104Z" },+ { url = "https://files.pythonhosted.org/packages/7c/89/d70e9f628749b7e4db2aa4cd89735502ff3f08f7b9b27d2e799485987cd9/scipy-1.16.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:8be1ca9170fcb6223cc7c27f4305d680ded114a1567c0bd2bfcbf947d1b17511", size = 28941012, upload-time = "2025-10-28T17:31:53.411Z" },+ { url = "https://files.pythonhosted.org/packages/a8/a8/0e7a9a6872a923505dbdf6bb93451edcac120363131c19013044a1e7cb0c/scipy-1.16.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:bea0a62734d20d67608660f69dcda23e7f90fb4ca20974ab80b6ed40df87a005", size = 20931935, upload-time = "2025-10-28T17:31:57.361Z" },+ { url = "https://files.pythonhosted.org/packages/bd/c7/020fb72bd79ad798e4dbe53938543ecb96b3a9ac3fe274b7189e23e27353/scipy-1.16.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:2a207a6ce9c24f1951241f4693ede2d393f59c07abc159b2cb2be980820e01fb", size = 23534466, upload-time = "2025-10-28T17:32:01.875Z" },+ { url = "https://files.pythonhosted.org/packages/be/a0/668c4609ce6dbf2f948e167836ccaf897f95fb63fa231c87da7558a374cd/scipy-1.16.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:532fb5ad6a87e9e9cd9c959b106b73145a03f04c7d57ea3e6f6bb60b86ab0876", size = 33593618, upload-time = "2025-10-28T17:32:06.902Z" },+ { url = "https://files.pythonhosted.org/packages/ca/6e/8942461cf2636cdae083e3eb72622a7fbbfa5cf559c7d13ab250a5dbdc01/scipy-1.16.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0151a0749efeaaab78711c78422d413c583b8cdd2011a3c1d6c794938ee9fdb2", size = 35899798, upload-time = "2025-10-28T17:32:12.665Z" },+ { url = "https://files.pythonhosted.org/packages/79/e8/d0f33590364cdbd67f28ce79368b373889faa4ee959588beddf6daef9abe/scipy-1.16.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b7180967113560cca57418a7bc719e30366b47959dd845a93206fbed693c867e", size = 36226154, upload-time = "2025-10-28T17:32:17.961Z" },+ { url = "https://files.pythonhosted.org/packages/39/c1/1903de608c0c924a1749c590064e65810f8046e437aba6be365abc4f7557/scipy-1.16.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:deb3841c925eeddb6afc1e4e4a45e418d19ec7b87c5df177695224078e8ec733", size = 38878540, upload-time = "2025-10-28T17:32:23.907Z" },+ { url = "https://files.pythonhosted.org/packages/f1/d0/22ec7036ba0b0a35bccb7f25ab407382ed34af0b111475eb301c16f8a2e5/scipy-1.16.3-cp311-cp311-win_amd64.whl", hash = "sha256:53c3844d527213631e886621df5695d35e4f6a75f620dca412bcd292f6b87d78", size = 38722107, upload-time = "2025-10-28T17:32:29.921Z" },+ { url = "https://files.pythonhosted.org/packages/7b/60/8a00e5a524bb3bf8898db1650d350f50e6cffb9d7a491c561dc9826c7515/scipy-1.16.3-cp311-cp311-win_arm64.whl", hash = "sha256:9452781bd879b14b6f055b26643703551320aa8d79ae064a71df55c00286a184", size = 25506272, upload-time = "2025-10-28T17:32:34.577Z" },+ { url = "https://files.pythonhosted.org/packages/40/41/5bf55c3f386b1643812f3a5674edf74b26184378ef0f3e7c7a09a7e2ca7f/scipy-1.16.3-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:81fc5827606858cf71446a5e98715ba0e11f0dbc83d71c7409d05486592a45d6", size = 36659043, upload-time = "2025-10-28T17:32:40.285Z" },+ { url = "https://files.pythonhosted.org/packages/1e/0f/65582071948cfc45d43e9870bf7ca5f0e0684e165d7c9ef4e50d783073eb/scipy-1.16.3-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:c97176013d404c7346bf57874eaac5187d969293bf40497140b0a2b2b7482e07", size = 28898986, upload-time = "2025-10-28T17:32:45.325Z" },+ { url = "https://files.pythonhosted.org/packages/96/5e/36bf3f0ac298187d1ceadde9051177d6a4fe4d507e8f59067dc9dd39e650/scipy-1.16.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:2b71d93c8a9936046866acebc915e2af2e292b883ed6e2cbe5c34beb094b82d9", size = 20889814, upload-time = "2025-10-28T17:32:49.277Z" },+ { url = "https://files.pythonhosted.org/packages/80/35/178d9d0c35394d5d5211bbff7ac4f2986c5488b59506fef9e1de13ea28d3/scipy-1.16.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:3d4a07a8e785d80289dfe66b7c27d8634a773020742ec7187b85ccc4b0e7b686", size = 23565795, upload-time = "2025-10-28T17:32:53.337Z" },+ { url = "https://files.pythonhosted.org/packages/fa/46/d1146ff536d034d02f83c8afc3c4bab2eddb634624d6529a8512f3afc9da/scipy-1.16.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0553371015692a898e1aa858fed67a3576c34edefa6b7ebdb4e9dde49ce5c203", size = 33349476, upload-time = "2025-10-28T17:32:58.353Z" },+ { url = "https://files.pythonhosted.org/packages/79/2e/415119c9ab3e62249e18c2b082c07aff907a273741b3f8160414b0e9193c/scipy-1.16.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:72d1717fd3b5e6ec747327ce9bda32d5463f472c9dce9f54499e81fbd50245a1", size = 35676692, upload-time = "2025-10-28T17:33:03.88Z" },+ { url = "https://files.pythonhosted.org/packages/27/82/df26e44da78bf8d2aeaf7566082260cfa15955a5a6e96e6a29935b64132f/scipy-1.16.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1fb2472e72e24d1530debe6ae078db70fb1605350c88a3d14bc401d6306dbffe", size = 36019345, upload-time = "2025-10-28T17:33:09.773Z" },+ { url = "https://files.pythonhosted.org/packages/82/31/006cbb4b648ba379a95c87262c2855cd0d09453e500937f78b30f02fa1cd/scipy-1.16.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c5192722cffe15f9329a3948c4b1db789fbb1f05c97899187dcf009b283aea70", size = 38678975, upload-time = "2025-10-28T17:33:15.809Z" },+ { url = "https://files.pythonhosted.org/packages/c2/7f/acbd28c97e990b421af7d6d6cd416358c9c293fc958b8529e0bd5d2a2a19/scipy-1.16.3-cp312-cp312-win_amd64.whl", hash = "sha256:56edc65510d1331dae01ef9b658d428e33ed48b4f77b1d51caf479a0253f96dc", size = 38555926, upload-time = "2025-10-28T17:33:21.388Z" },+ { url = "https://files.pythonhosted.org/packages/ce/69/c5c7807fd007dad4f48e0a5f2153038dc96e8725d3345b9ee31b2b7bed46/scipy-1.16.3-cp312-cp312-win_arm64.whl", hash = "sha256:a8a26c78ef223d3e30920ef759e25625a0ecdd0d60e5a8818b7513c3e5384cf2", size = 25463014, upload-time = "2025-10-28T17:33:25.975Z" },+ { url = "https://files.pythonhosted.org/packages/72/f1/57e8327ab1508272029e27eeef34f2302ffc156b69e7e233e906c2a5c379/scipy-1.16.3-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:d2ec56337675e61b312179a1ad124f5f570c00f920cc75e1000025451b88241c", size = 36617856, upload-time = "2025-10-28T17:33:31.375Z" },+ { url = "https://files.pythonhosted.org/packages/44/13/7e63cfba8a7452eb756306aa2fd9b37a29a323b672b964b4fdeded9a3f21/scipy-1.16.3-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:16b8bc35a4cc24db80a0ec836a9286d0e31b2503cb2fd7ff7fb0e0374a97081d", size = 28874306, upload-time = "2025-10-28T17:33:36.516Z" },+ { url = "https://files.pythonhosted.org/packages/15/65/3a9400efd0228a176e6ec3454b1fa998fbbb5a8defa1672c3f65706987db/scipy-1.16.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:5803c5fadd29de0cf27fa08ccbfe7a9e5d741bf63e4ab1085437266f12460ff9", size = 20865371, upload-time = "2025-10-28T17:33:42.094Z" },+ { url = "https://files.pythonhosted.org/packages/33/d7/eda09adf009a9fb81827194d4dd02d2e4bc752cef16737cc4ef065234031/scipy-1.16.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:b81c27fc41954319a943d43b20e07c40bdcd3ff7cf013f4fb86286faefe546c4", size = 23524877, upload-time = "2025-10-28T17:33:48.483Z" },+ { url = "https://files.pythonhosted.org/packages/7d/6b/3f911e1ebc364cb81320223a3422aab7d26c9c7973109a9cd0f27c64c6c0/scipy-1.16.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0c3b4dd3d9b08dbce0f3440032c52e9e2ab9f96ade2d3943313dfe51a7056959", size = 33342103, upload-time = "2025-10-28T17:33:56.495Z" },+ { url = "https://files.pythonhosted.org/packages/21/f6/4bfb5695d8941e5c570a04d9fcd0d36bce7511b7d78e6e75c8f9791f82d0/scipy-1.16.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7dc1360c06535ea6116a2220f760ae572db9f661aba2d88074fe30ec2aa1ff88", size = 35697297, upload-time = "2025-10-28T17:34:04.722Z" },+ { url = "https://files.pythonhosted.org/packages/04/e1/6496dadbc80d8d896ff72511ecfe2316b50313bfc3ebf07a3f580f08bd8c/scipy-1.16.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:663b8d66a8748051c3ee9c96465fb417509315b99c71550fda2591d7dd634234", size = 36021756, upload-time = "2025-10-28T17:34:13.482Z" },+ { url = "https://files.pythonhosted.org/packages/fe/bd/a8c7799e0136b987bda3e1b23d155bcb31aec68a4a472554df5f0937eef7/scipy-1.16.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eab43fae33a0c39006a88096cd7b4f4ef545ea0447d250d5ac18202d40b6611d", size = 38696566, upload-time = "2025-10-28T17:34:22.384Z" },+ { url = "https://files.pythonhosted.org/packages/cd/01/1204382461fcbfeb05b6161b594f4007e78b6eba9b375382f79153172b4d/scipy-1.16.3-cp313-cp313-win_amd64.whl", hash = "sha256:062246acacbe9f8210de8e751b16fc37458213f124bef161a5a02c7a39284304", size = 38529877, upload-time = "2025-10-28T17:35:51.076Z" },+ { url = "https://files.pythonhosted.org/packages/7f/14/9d9fbcaa1260a94f4bb5b64ba9213ceb5d03cd88841fe9fd1ffd47a45b73/scipy-1.16.3-cp313-cp313-win_arm64.whl", hash = "sha256:50a3dbf286dbc7d84f176f9a1574c705f277cb6565069f88f60db9eafdbe3ee2", size = 25455366, upload-time = "2025-10-28T17:35:59.014Z" },+ { url = "https://files.pythonhosted.org/packages/e2/a3/9ec205bd49f42d45d77f1730dbad9ccf146244c1647605cf834b3a8c4f36/scipy-1.16.3-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:fb4b29f4cf8cc5a8d628bc8d8e26d12d7278cd1f219f22698a378c3d67db5e4b", size = 37027931, upload-time = "2025-10-28T17:34:31.451Z" },+ { url = "https://files.pythonhosted.org/packages/25/06/ca9fd1f3a4589cbd825b1447e5db3a8ebb969c1eaf22c8579bd286f51b6d/scipy-1.16.3-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:8d09d72dc92742988b0e7750bddb8060b0c7079606c0d24a8cc8e9c9c11f9079", size = 29400081, upload-time = "2025-10-28T17:34:39.087Z" },+ { url = "https://files.pythonhosted.org/packages/6a/56/933e68210d92657d93fb0e381683bc0e53a965048d7358ff5fbf9e6a1b17/scipy-1.16.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:03192a35e661470197556de24e7cb1330d84b35b94ead65c46ad6f16f6b28f2a", size = 21391244, upload-time = "2025-10-28T17:34:45.234Z" },+ { url = "https://files.pythonhosted.org/packages/a8/7e/779845db03dc1418e215726329674b40576879b91814568757ff0014ad65/scipy-1.16.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:57d01cb6f85e34f0946b33caa66e892aae072b64b034183f3d87c4025802a119", size = 23929753, upload-time = "2025-10-28T17:34:51.793Z" },+ { url = "https://files.pythonhosted.org/packages/4c/4b/f756cf8161d5365dcdef9e5f460ab226c068211030a175d2fc7f3f41ca64/scipy-1.16.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:96491a6a54e995f00a28a3c3badfff58fd093bf26cd5fb34a2188c8c756a3a2c", size = 33496912, upload-time = "2025-10-28T17:34:59.8Z" },+ { url = "https://files.pythonhosted.org/packages/09/b5/222b1e49a58668f23839ca1542a6322bb095ab8d6590d4f71723869a6c2c/scipy-1.16.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cd13e354df9938598af2be05822c323e97132d5e6306b83a3b4ee6724c6e522e", size = 35802371, upload-time = "2025-10-28T17:35:08.173Z" },+ { url = "https://files.pythonhosted.org/packages/c1/8d/5964ef68bb31829bde27611f8c9deeac13764589fe74a75390242b64ca44/scipy-1.16.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:63d3cdacb8a824a295191a723ee5e4ea7768ca5ca5f2838532d9f2e2b3ce2135", size = 36190477, upload-time = "2025-10-28T17:35:16.7Z" },+ { url = "https://files.pythonhosted.org/packages/ab/f2/b31d75cb9b5fa4dd39a0a931ee9b33e7f6f36f23be5ef560bf72e0f92f32/scipy-1.16.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e7efa2681ea410b10dde31a52b18b0154d66f2485328830e45fdf183af5aefc6", size = 38796678, upload-time = "2025-10-28T17:35:26.354Z" },+ { url = "https://files.pythonhosted.org/packages/b4/1e/b3723d8ff64ab548c38d87055483714fefe6ee20e0189b62352b5e015bb1/scipy-1.16.3-cp313-cp313t-win_amd64.whl", hash = "sha256:2d1ae2cf0c350e7705168ff2429962a89ad90c2d49d1dd300686d8b2a5af22fc", size = 38640178, upload-time = "2025-10-28T17:35:35.304Z" },+ { url = "https://files.pythonhosted.org/packages/8e/f3/d854ff38789aca9b0cc23008d607ced9de4f7ab14fa1ca4329f86b3758ca/scipy-1.16.3-cp313-cp313t-win_arm64.whl", hash = "sha256:0c623a54f7b79dd88ef56da19bc2873afec9673a48f3b85b18e4d402bdd29a5a", size = 25803246, upload-time = "2025-10-28T17:35:42.155Z" },+ { url = "https://files.pythonhosted.org/packages/99/f6/99b10fd70f2d864c1e29a28bbcaa0c6340f9d8518396542d9ea3b4aaae15/scipy-1.16.3-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:875555ce62743e1d54f06cdf22c1e0bc47b91130ac40fe5d783b6dfa114beeb6", size = 36606469, upload-time = "2025-10-28T17:36:08.741Z" },+ { url = "https://files.pythonhosted.org/packages/4d/74/043b54f2319f48ea940dd025779fa28ee360e6b95acb7cd188fad4391c6b/scipy-1.16.3-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:bb61878c18a470021fb515a843dc7a76961a8daceaaaa8bad1332f1bf4b54657", size = 28872043, upload-time = "2025-10-28T17:36:16.599Z" },+ { url = "https://files.pythonhosted.org/packages/4d/e1/24b7e50cc1c4ee6ffbcb1f27fe9f4c8b40e7911675f6d2d20955f41c6348/scipy-1.16.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:f2622206f5559784fa5c4b53a950c3c7c1cf3e84ca1b9c4b6c03f062f289ca26", size = 20862952, upload-time = "2025-10-28T17:36:22.966Z" },+ { url = "https://files.pythonhosted.org/packages/dd/3a/3e8c01a4d742b730df368e063787c6808597ccb38636ed821d10b39ca51b/scipy-1.16.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:7f68154688c515cdb541a31ef8eb66d8cd1050605be9dcd74199cbd22ac739bc", size = 23508512, upload-time = "2025-10-28T17:36:29.731Z" },+ { url = "https://files.pythonhosted.org/packages/1f/60/c45a12b98ad591536bfe5330cb3cfe1850d7570259303563b1721564d458/scipy-1.16.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8b3c820ddb80029fe9f43d61b81d8b488d3ef8ca010d15122b152db77dc94c22", size = 33413639, upload-time = "2025-10-28T17:36:37.982Z" },+ { url = "https://files.pythonhosted.org/packages/71/bc/35957d88645476307e4839712642896689df442f3e53b0fa016ecf8a3357/scipy-1.16.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d3837938ae715fc0fe3c39c0202de3a8853aff22ca66781ddc2ade7554b7e2cc", size = 35704729, upload-time = "2025-10-28T17:36:46.547Z" },+ { url = "https://files.pythonhosted.org/packages/3b/15/89105e659041b1ca11c386e9995aefacd513a78493656e57789f9d9eab61/scipy-1.16.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aadd23f98f9cb069b3bd64ddc900c4d277778242e961751f77a8cb5c4b946fb0", size = 36086251, upload-time = "2025-10-28T17:36:55.161Z" },+ { url = "https://files.pythonhosted.org/packages/1a/87/c0ea673ac9c6cc50b3da2196d860273bc7389aa69b64efa8493bdd25b093/scipy-1.16.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b7c5f1bda1354d6a19bc6af73a649f8285ca63ac6b52e64e658a5a11d4d69800", size = 38716681, upload-time = "2025-10-28T17:37:04.1Z" },+ { url = "https://files.pythonhosted.org/packages/91/06/837893227b043fb9b0d13e4bd7586982d8136cb249ffb3492930dab905b8/scipy-1.16.3-cp314-cp314-win_amd64.whl", hash = "sha256:e5d42a9472e7579e473879a1990327830493a7047506d58d73fc429b84c1d49d", size = 39358423, upload-time = "2025-10-28T17:38:20.005Z" },+ { url = "https://files.pythonhosted.org/packages/95/03/28bce0355e4d34a7c034727505a02d19548549e190bedd13a721e35380b7/scipy-1.16.3-cp314-cp314-win_arm64.whl", hash = "sha256:6020470b9d00245926f2d5bb93b119ca0340f0d564eb6fbaad843eaebf9d690f", size = 26135027, upload-time = "2025-10-28T17:38:24.966Z" },+ { url = "https://files.pythonhosted.org/packages/b2/6f/69f1e2b682efe9de8fe9f91040f0cd32f13cfccba690512ba4c582b0bc29/scipy-1.16.3-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:e1d27cbcb4602680a49d787d90664fa4974063ac9d4134813332a8c53dbe667c", size = 37028379, upload-time = "2025-10-28T17:37:14.061Z" },+ { url = "https://files.pythonhosted.org/packages/7c/2d/e826f31624a5ebbab1cd93d30fd74349914753076ed0593e1d56a98c4fb4/scipy-1.16.3-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:9b9c9c07b6d56a35777a1b4cc8966118fb16cfd8daf6743867d17d36cfad2d40", size = 29400052, upload-time = "2025-10-28T17:37:21.709Z" },+ { url = "https://files.pythonhosted.org/packages/69/27/d24feb80155f41fd1f156bf144e7e049b4e2b9dd06261a242905e3bc7a03/scipy-1.16.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:3a4c460301fb2cffb7f88528f30b3127742cff583603aa7dc964a52c463b385d", size = 21391183, upload-time = "2025-10-28T17:37:29.559Z" },+ { url = "https://files.pythonhosted.org/packages/f8/d3/1b229e433074c5738a24277eca520a2319aac7465eea7310ea6ae0e98ae2/scipy-1.16.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:f667a4542cc8917af1db06366d3f78a5c8e83badd56409f94d1eac8d8d9133fa", size = 23930174, upload-time = "2025-10-28T17:37:36.306Z" },+ { url = "https://files.pythonhosted.org/packages/16/9d/d9e148b0ec680c0f042581a2be79a28a7ab66c0c4946697f9e7553ead337/scipy-1.16.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f379b54b77a597aa7ee5e697df0d66903e41b9c85a6dd7946159e356319158e8", size = 33497852, upload-time = "2025-10-28T17:37:42.228Z" },+ { url = "https://files.pythonhosted.org/packages/2f/22/4e5f7561e4f98b7bea63cf3fd7934bff1e3182e9f1626b089a679914d5c8/scipy-1.16.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4aff59800a3b7f786b70bfd6ab551001cb553244988d7d6b8299cb1ea653b353", size = 35798595, upload-time = "2025-10-28T17:37:48.102Z" },+ { url = "https://files.pythonhosted.org/packages/83/42/6644d714c179429fc7196857866f219fef25238319b650bb32dde7bf7a48/scipy-1.16.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:da7763f55885045036fabcebd80144b757d3db06ab0861415d1c3b7c69042146", size = 36186269, upload-time = "2025-10-28T17:37:53.72Z" },+ { url = "https://files.pythonhosted.org/packages/ac/70/64b4d7ca92f9cf2e6fc6aaa2eecf80bb9b6b985043a9583f32f8177ea122/scipy-1.16.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ffa6eea95283b2b8079b821dc11f50a17d0571c92b43e2b5b12764dc5f9b285d", size = 38802779, upload-time = "2025-10-28T17:37:59.393Z" },+ { url = "https://files.pythonhosted.org/packages/61/82/8d0e39f62764cce5ffd5284131e109f07cf8955aef9ab8ed4e3aa5e30539/scipy-1.16.3-cp314-cp314t-win_amd64.whl", hash = "sha256:d9f48cafc7ce94cf9b15c6bffdc443a81a27bf7075cf2dcd5c8b40f85d10c4e7", size = 39471128, upload-time = "2025-10-28T17:38:05.259Z" },+ { url = "https://files.pythonhosted.org/packages/64/47/a494741db7280eae6dc033510c319e34d42dd41b7ac0c7ead39354d1a2b5/scipy-1.16.3-cp314-cp314t-win_arm64.whl", hash = "sha256:21d9d6b197227a12dcbf9633320a4e34c6b0e51c57268df255a0942983bac562", size = 26464127, upload-time = "2025-10-28T17:38:11.34Z" },][[package]]name = "setproctitle"version = "1.3.3"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/ff/e1/b16b16a1aa12174349d15b73fd4b87e641a8ae3fb1163e80938dbbf6ae98/setproctitle-1.3.3.tar.gz", hash = "sha256:c913e151e7ea01567837ff037a23ca8740192880198b7fbb90b16d181607caae", size = 27253 }-wheels = [- { url = "https://files.pythonhosted.org/packages/c9/17/7f9d5ddf4cfc4386e74565ccf63b8381396336e4629bb165b52b803ceddb/setproctitle-1.3.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:334f7ed39895d692f753a443102dd5fed180c571eb6a48b2a5b7f5b3564908c8", size = 16948 },- { url = "https://files.pythonhosted.org/packages/ff/5d/77edf4c29c8d6728b49d3f0abb22159bb9c0c4ddebd721c09486b34985c8/setproctitle-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:950f6476d56ff7817a8fed4ab207727fc5260af83481b2a4b125f32844df513a", size = 11305 },- { url = "https://files.pythonhosted.org/packages/13/f0/263954ca925a278036f100405e7ba82d4341e1e6bdc09f35362a7b40f684/setproctitle-1.3.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:195c961f54a09eb2acabbfc90c413955cf16c6e2f8caa2adbf2237d1019c7dd8", size = 31578 },- { url = "https://files.pythonhosted.org/packages/79/52/503b546da451deb78fde27fec96c39d3f63a7958be60c9a837de89f47a0d/setproctitle-1.3.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f05e66746bf9fe6a3397ec246fe481096664a9c97eb3fea6004735a4daf867fd", size = 32910 },- { url = "https://files.pythonhosted.org/packages/48/72/aeb734419a58a85ca7845c3d0011c322597da4ff601ebbc28f6c1dfd1ae8/setproctitle-1.3.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b5901a31012a40ec913265b64e48c2a4059278d9f4e6be628441482dd13fb8b5", size = 30086 },- { url = "https://files.pythonhosted.org/packages/fd/df/44b267cb8f073a4ae77e120f0705ab3a07165ad90cecd4881b34c7e1e37b/setproctitle-1.3.3-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64286f8a995f2cd934082b398fc63fca7d5ffe31f0e27e75b3ca6b4efda4e353", size = 31076 },- { url = "https://files.pythonhosted.org/packages/82/c2/79ad43c914418cb1920e0198ac7326061c05cd4ec75c86ed0ca456b7e957/setproctitle-1.3.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:184239903bbc6b813b1a8fc86394dc6ca7d20e2ebe6f69f716bec301e4b0199d", size = 41226 },- { url = "https://files.pythonhosted.org/packages/81/1b/0498c36a07a73d39a7070f45d96a299006e624efc07fc2e2296286237316/setproctitle-1.3.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:664698ae0013f986118064b6676d7dcd28fefd0d7d5a5ae9497cbc10cba48fa5", size = 39723 },- { url = "https://files.pythonhosted.org/packages/3a/fe/ebbcffd6012b9cf5edb017a9c30cfc2beccf707f5bf495da8cf69b4abe69/setproctitle-1.3.3-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:e5119a211c2e98ff18b9908ba62a3bd0e3fabb02a29277a7232a6fb4b2560aa0", size = 42773 },- { url = "https://files.pythonhosted.org/packages/64/b1/5786c0442435eb18d04299c8ce7d1f86feb5154444ac684963527a76e169/setproctitle-1.3.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:417de6b2e214e837827067048f61841f5d7fc27926f2e43954567094051aff18", size = 41089 },- { url = "https://files.pythonhosted.org/packages/33/fb/14b41e920406a12de0a164ef3b86d62edb4fac63d91d9f86f3b80dae5b38/setproctitle-1.3.3-cp311-cp311-win32.whl", hash = "sha256:6a143b31d758296dc2f440175f6c8e0b5301ced3b0f477b84ca43cdcf7f2f476", size = 11066 },- { url = "https://files.pythonhosted.org/packages/7e/ba/f6da9ba74e8c2c662e932b27a01025c1bee2846222f6a2e87a69c259772f/setproctitle-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:a680d62c399fa4b44899094027ec9a1bdaf6f31c650e44183b50d4c4d0ccc085", size = 11817 },- { url = "https://files.pythonhosted.org/packages/32/22/9672612b194e4ac5d9fb67922ad9d30232b4b66129b0381ab5efeb6ae88f/setproctitle-1.3.3-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:d4460795a8a7a391e3567b902ec5bdf6c60a47d791c3b1d27080fc203d11c9dc", size = 16917 },- { url = "https://files.pythonhosted.org/packages/49/e5/562ff00f2f3f4253ff8fa6886e0432b8eae8cde82530ac19843d8ed2c485/setproctitle-1.3.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:bdfd7254745bb737ca1384dee57e6523651892f0ea2a7344490e9caefcc35e64", size = 11264 },- { url = "https://files.pythonhosted.org/packages/8f/1f/f97ea7bf71c873590a63d62ba20bf7294439d1c28603e5c63e3616c2131a/setproctitle-1.3.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:477d3da48e216d7fc04bddab67b0dcde633e19f484a146fd2a34bb0e9dbb4a1e", size = 31907 },- { url = "https://files.pythonhosted.org/packages/66/fb/2d90806b9a2ed97c140baade3d1d2d41d3b51458300a2d999268be24d21d/setproctitle-1.3.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ab2900d111e93aff5df9fddc64cf51ca4ef2c9f98702ce26524f1acc5a786ae7", size = 33333 },- { url = "https://files.pythonhosted.org/packages/38/39/e7ce791f5635f3a16bd21d6b79bd9280c4c4aed8ab936b4b21334acf05a7/setproctitle-1.3.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:088b9efc62d5aa5d6edf6cba1cf0c81f4488b5ce1c0342a8b67ae39d64001120", size = 30573 },- { url = "https://files.pythonhosted.org/packages/20/22/fd76bbde4194d4e31d5b31a02f80c8e7e54a99d3d8ff34f3d656c6655689/setproctitle-1.3.3-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a6d50252377db62d6a0bb82cc898089916457f2db2041e1d03ce7fadd4a07381", size = 31601 },- { url = "https://files.pythonhosted.org/packages/51/5c/a6257cc68e17abcc4d4a78cc6666aa0d3805af6d942576625c4a468a72f0/setproctitle-1.3.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:87e668f9561fd3a457ba189edfc9e37709261287b52293c115ae3487a24b92f6", size = 40717 },- { url = "https://files.pythonhosted.org/packages/db/31/4f0faad7ef641be4e8dfcbc40829775f2d6a4ca1ff435a4074047fa3dad1/setproctitle-1.3.3-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:287490eb90e7a0ddd22e74c89a92cc922389daa95babc833c08cf80c84c4df0a", size = 39384 },- { url = "https://files.pythonhosted.org/packages/22/17/8763dc4f9ddf36af5f043ceec213b0f9f45f09fd2d5061a89c699aabe8b0/setproctitle-1.3.3-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:4fe1c49486109f72d502f8be569972e27f385fe632bd8895f4730df3c87d5ac8", size = 42350 },- { url = "https://files.pythonhosted.org/packages/7b/b2/2403cecf2e5c5b4da22f7d9df4b2149bf92d03a3422185e682e81055549c/setproctitle-1.3.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4a6ba2494a6449b1f477bd3e67935c2b7b0274f2f6dcd0f7c6aceae10c6c6ba3", size = 40704 },- { url = "https://files.pythonhosted.org/packages/5e/c1/11e80061ac06aece2a0ffcaf018cdc088aebb2fc586f68201755518532ad/setproctitle-1.3.3-cp312-cp312-win32.whl", hash = "sha256:2df2b67e4b1d7498632e18c56722851ba4db5d6a0c91aaf0fd395111e51cdcf4", size = 11057 },- { url = "https://files.pythonhosted.org/packages/90/e8/ece468e93e99d3b2826e9649f6d03e80f071d451e20c742f201f77d1bea1/setproctitle-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:f38d48abc121263f3b62943f84cbaede05749047e428409c2c199664feb6abc7", size = 11809 },+sdist = { url = "https://files.pythonhosted.org/packages/ff/e1/b16b16a1aa12174349d15b73fd4b87e641a8ae3fb1163e80938dbbf6ae98/setproctitle-1.3.3.tar.gz", hash = "sha256:c913e151e7ea01567837ff037a23ca8740192880198b7fbb90b16d181607caae", size = 27253, upload-time = "2023-10-03T17:14:17.724Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/c9/17/7f9d5ddf4cfc4386e74565ccf63b8381396336e4629bb165b52b803ceddb/setproctitle-1.3.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:334f7ed39895d692f753a443102dd5fed180c571eb6a48b2a5b7f5b3564908c8", size = 16948, upload-time = "2023-10-03T17:12:08.745Z" },+ { url = "https://files.pythonhosted.org/packages/ff/5d/77edf4c29c8d6728b49d3f0abb22159bb9c0c4ddebd721c09486b34985c8/setproctitle-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:950f6476d56ff7817a8fed4ab207727fc5260af83481b2a4b125f32844df513a", size = 11305, upload-time = "2023-10-03T17:12:10.449Z" },+ { url = "https://files.pythonhosted.org/packages/13/f0/263954ca925a278036f100405e7ba82d4341e1e6bdc09f35362a7b40f684/setproctitle-1.3.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:195c961f54a09eb2acabbfc90c413955cf16c6e2f8caa2adbf2237d1019c7dd8", size = 31578, upload-time = "2023-10-03T17:12:11.746Z" },+ { url = "https://files.pythonhosted.org/packages/79/52/503b546da451deb78fde27fec96c39d3f63a7958be60c9a837de89f47a0d/setproctitle-1.3.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f05e66746bf9fe6a3397ec246fe481096664a9c97eb3fea6004735a4daf867fd", size = 32910, upload-time = "2023-10-03T17:12:13.218Z" },+ { url = "https://files.pythonhosted.org/packages/48/72/aeb734419a58a85ca7845c3d0011c322597da4ff601ebbc28f6c1dfd1ae8/setproctitle-1.3.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b5901a31012a40ec913265b64e48c2a4059278d9f4e6be628441482dd13fb8b5", size = 30086, upload-time = "2023-10-03T17:12:15.157Z" },+ { url = "https://files.pythonhosted.org/packages/fd/df/44b267cb8f073a4ae77e120f0705ab3a07165ad90cecd4881b34c7e1e37b/setproctitle-1.3.3-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64286f8a995f2cd934082b398fc63fca7d5ffe31f0e27e75b3ca6b4efda4e353", size = 31076, upload-time = "2023-10-03T17:12:17.144Z" },+ { url = "https://files.pythonhosted.org/packages/82/c2/79ad43c914418cb1920e0198ac7326061c05cd4ec75c86ed0ca456b7e957/setproctitle-1.3.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:184239903bbc6b813b1a8fc86394dc6ca7d20e2ebe6f69f716bec301e4b0199d", size = 41226, upload-time = "2023-10-03T17:12:19.125Z" },+ { url = "https://files.pythonhosted.org/packages/81/1b/0498c36a07a73d39a7070f45d96a299006e624efc07fc2e2296286237316/setproctitle-1.3.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:664698ae0013f986118064b6676d7dcd28fefd0d7d5a5ae9497cbc10cba48fa5", size = 39723, upload-time = "2023-10-03T17:12:21.007Z" },+ { url = "https://files.pythonhosted.org/packages/3a/fe/ebbcffd6012b9cf5edb017a9c30cfc2beccf707f5bf495da8cf69b4abe69/setproctitle-1.3.3-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:e5119a211c2e98ff18b9908ba62a3bd0e3fabb02a29277a7232a6fb4b2560aa0", size = 42773, upload-time = "2023-10-03T17:12:22.915Z" },+ { url = "https://files.pythonhosted.org/packages/64/b1/5786c0442435eb18d04299c8ce7d1f86feb5154444ac684963527a76e169/setproctitle-1.3.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:417de6b2e214e837827067048f61841f5d7fc27926f2e43954567094051aff18", size = 41089, upload-time = "2023-10-03T17:12:24.911Z" },+ { url = "https://files.pythonhosted.org/packages/33/fb/14b41e920406a12de0a164ef3b86d62edb4fac63d91d9f86f3b80dae5b38/setproctitle-1.3.3-cp311-cp311-win32.whl", hash = "sha256:6a143b31d758296dc2f440175f6c8e0b5301ced3b0f477b84ca43cdcf7f2f476", size = 11066, upload-time = "2023-10-03T17:12:26.395Z" },+ { url = "https://files.pythonhosted.org/packages/7e/ba/f6da9ba74e8c2c662e932b27a01025c1bee2846222f6a2e87a69c259772f/setproctitle-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:a680d62c399fa4b44899094027ec9a1bdaf6f31c650e44183b50d4c4d0ccc085", size = 11817, upload-time = "2023-10-03T17:12:28.139Z" },+ { url = "https://files.pythonhosted.org/packages/32/22/9672612b194e4ac5d9fb67922ad9d30232b4b66129b0381ab5efeb6ae88f/setproctitle-1.3.3-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:d4460795a8a7a391e3567b902ec5bdf6c60a47d791c3b1d27080fc203d11c9dc", size = 16917, upload-time = "2023-10-03T17:12:29.281Z" },+ { url = "https://files.pythonhosted.org/packages/49/e5/562ff00f2f3f4253ff8fa6886e0432b8eae8cde82530ac19843d8ed2c485/setproctitle-1.3.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:bdfd7254745bb737ca1384dee57e6523651892f0ea2a7344490e9caefcc35e64", size = 11264, upload-time = "2023-10-03T17:12:31.091Z" },+ { url = "https://files.pythonhosted.org/packages/8f/1f/f97ea7bf71c873590a63d62ba20bf7294439d1c28603e5c63e3616c2131a/setproctitle-1.3.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:477d3da48e216d7fc04bddab67b0dcde633e19f484a146fd2a34bb0e9dbb4a1e", size = 31907, upload-time = "2023-10-03T17:12:32.592Z" },+ { url = "https://files.pythonhosted.org/packages/66/fb/2d90806b9a2ed97c140baade3d1d2d41d3b51458300a2d999268be24d21d/setproctitle-1.3.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ab2900d111e93aff5df9fddc64cf51ca4ef2c9f98702ce26524f1acc5a786ae7", size = 33333, upload-time = "2023-10-03T17:12:33.89Z" },+ { url = "https://files.pythonhosted.org/packages/38/39/e7ce791f5635f3a16bd21d6b79bd9280c4c4aed8ab936b4b21334acf05a7/setproctitle-1.3.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:088b9efc62d5aa5d6edf6cba1cf0c81f4488b5ce1c0342a8b67ae39d64001120", size = 30573, upload-time = "2023-10-03T17:12:35.264Z" },+ { url = "https://files.pythonhosted.org/packages/20/22/fd76bbde4194d4e31d5b31a02f80c8e7e54a99d3d8ff34f3d656c6655689/setproctitle-1.3.3-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a6d50252377db62d6a0bb82cc898089916457f2db2041e1d03ce7fadd4a07381", size = 31601, upload-time = "2023-10-03T17:12:36.807Z" },+ { url = "https://files.pythonhosted.org/packages/51/5c/a6257cc68e17abcc4d4a78cc6666aa0d3805af6d942576625c4a468a72f0/setproctitle-1.3.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:87e668f9561fd3a457ba189edfc9e37709261287b52293c115ae3487a24b92f6", size = 40717, upload-time = "2023-10-03T17:12:38.542Z" },+ { url = "https://files.pythonhosted.org/packages/db/31/4f0faad7ef641be4e8dfcbc40829775f2d6a4ca1ff435a4074047fa3dad1/setproctitle-1.3.3-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:287490eb90e7a0ddd22e74c89a92cc922389daa95babc833c08cf80c84c4df0a", size = 39384, upload-time = "2023-10-03T17:12:39.96Z" },+ { url = "https://files.pythonhosted.org/packages/22/17/8763dc4f9ddf36af5f043ceec213b0f9f45f09fd2d5061a89c699aabe8b0/setproctitle-1.3.3-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:4fe1c49486109f72d502f8be569972e27f385fe632bd8895f4730df3c87d5ac8", size = 42350, upload-time = "2023-10-03T17:12:41.371Z" },+ { url = "https://files.pythonhosted.org/packages/7b/b2/2403cecf2e5c5b4da22f7d9df4b2149bf92d03a3422185e682e81055549c/setproctitle-1.3.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4a6ba2494a6449b1f477bd3e67935c2b7b0274f2f6dcd0f7c6aceae10c6c6ba3", size = 40704, upload-time = "2023-10-03T17:12:44.272Z" },+ { url = "https://files.pythonhosted.org/packages/5e/c1/11e80061ac06aece2a0ffcaf018cdc088aebb2fc586f68201755518532ad/setproctitle-1.3.3-cp312-cp312-win32.whl", hash = "sha256:2df2b67e4b1d7498632e18c56722851ba4db5d6a0c91aaf0fd395111e51cdcf4", size = 11057, upload-time = "2023-10-03T17:12:47.522Z" },+ { url = "https://files.pythonhosted.org/packages/90/e8/ece468e93e99d3b2826e9649f6d03e80f071d451e20c742f201f77d1bea1/setproctitle-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:f38d48abc121263f3b62943f84cbaede05749047e428409c2c199664feb6abc7", size = 11809, upload-time = "2023-10-03T17:12:48.935Z" },][[package]]name = "setuptools"-version = "80.9.0"+version = "82.0.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/18/5d/3bf57dcd21979b887f014ea83c24ae194cfcd12b9e0fda66b957c69d1fca/setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c", size = 1319958 }+sdist = { url = "https://files.pythonhosted.org/packages/82/f3/748f4d6f65d1756b9ae577f329c951cda23fb900e4de9f70900ced962085/setuptools-82.0.0.tar.gz", hash = "sha256:22e0a2d69474c6ae4feb01951cb69d515ed23728cf96d05513d36e42b62b37cb", size = 1144893, upload-time = "2026-02-08T15:08:40.206Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486 },+ { url = "https://files.pythonhosted.org/packages/e1/c6/76dc613121b793286a3f91621d7b75a2b493e0390ddca50f11993eadf192/setuptools-82.0.0-py3-none-any.whl", hash = "sha256:70b18734b607bd1da571d097d236cfcfacaf01de45717d59e6e04b96877532e0", size = 1003468, upload-time = "2026-02-08T15:08:38.723Z" },][[package]]name = "six"version = "1.17.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 }+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 },+ { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },][[package]]@@ -2024,21 +2026,22 @@ dependencies = [{ name = "matplotlib" },{ name = "numpy" },{ name = "opencv-contrib-python" },- { name = "pandas" },+ { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.14'" },+ { name = "pandas", version = "3.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.14'" },{ name = "pyqt6" },{ name = "pytest" },{ name = "requests" },{ name = "rich" },]-sdist = { url = "https://files.pythonhosted.org/packages/53/ba/771cdb85fb99f7c97e869a37d6d71333c1d7f0a981a0ca797d5a81181302/skelly_viewer-2023.5.1019.tar.gz", hash = "sha256:96fc747083fd9cfcb4352de2e8f1e225696c74d736d9b558f4542aba78150512", size = 16582 }+sdist = { url = "https://files.pythonhosted.org/packages/53/ba/771cdb85fb99f7c97e869a37d6d71333c1d7f0a981a0ca797d5a81181302/skelly_viewer-2023.5.1019.tar.gz", hash = "sha256:96fc747083fd9cfcb4352de2e8f1e225696c74d736d9b558f4542aba78150512", size = 16582, upload-time = "2023-05-25T18:23:56.566Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/e3/4a/6cb17228d54aa179b09cea08c6fddff0dbbd7395dfe37d9947f1a7a474f5/skelly_viewer-2023.5.1019-py3-none-any.whl", hash = "sha256:a73e3c70712e3d597d3099b9b3375981b201f3238e3eb5a0af89e7d47b8b2608", size = 22335 },+ { url = "https://files.pythonhosted.org/packages/e3/4a/6cb17228d54aa179b09cea08c6fddff0dbbd7395dfe37d9947f1a7a474f5/skelly_viewer-2023.5.1019-py3-none-any.whl", hash = "sha256:a73e3c70712e3d597d3099b9b3375981b201f3238e3eb5a0af89e7d47b8b2608", size = 22335, upload-time = "2023-05-25T18:23:55.145Z" },][[package]]name = "skellycam"-version = "2023.9.1086"-source = { git = "https://github.com/freemocap/skellycam?branch=jon%2Fdevelopment#81294e899bd220f721bb2f7b69a906b665440719" }+version = "2024.9.1094"+source = { git = "https://github.com/freemocap/skellycam?branch=development#dc19afd74100b931e8bd6a5435ca78dd54733812" }dependencies = [{ name = "cv2-enumerate-cameras" },{ name = "fastapi" },@@ -2046,7 +2049,8 @@ dependencies = [{ name = "numpy" },{ name = "numpydantic" },{ name = "opencv-contrib-python" },- { name = "pandas" },+ { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.14'" },+ { name = "pandas", version = "3.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.14'" },{ name = "pillow" },{ name = "psutil" },{ name = "pydantic" },@@ -2061,10 +2065,11 @@ dependencies = [[[package]]name = "skellyforge"version = "2024.12.1009"-source = { git = "https://github.com/freemocap/skellyforge?branch=jon%2Fdevelopment#eedf81f46886cc9edf95c8d8f4df15df3e99f387" }+source = { git = "https://github.com/freemocap/skellyforge?branch=development#1411181308bfe739c0e6e6b07b913d7c2e06a998" }dependencies = [{ name = "numpy" },- { name = "pandas" },+ { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.14'" },+ { name = "pandas", version = "3.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.14'" },{ name = "pyarrow" },{ name = "pyyaml" },{ name = "scipy" },@@ -2074,9 +2079,8 @@ dependencies = [[[package]]name = "skellytracker"version = "2024.9.1019"-source = { git = "https://github.com/freemocap/skellytracker?branch=jon%2Fdevelopment#39abbf930cff2c1e8ccd634be6074184dde05db6" }+source = { git = "https://github.com/freemocap/skellytracker?branch=development#1d3c11eb96f618a5f25d10cd583bb9d1395b2ed0" }dependencies = [- { name = "mediapipe" },{ name = "numpy" },{ name = "numpydantic" },{ name = "opencv-contrib-python" },@@ -2085,89 +2089,95 @@ dependencies = [{ name = "tqdm" },]-[[package]]-name = "sniffio"-version = "1.3.1"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 }-wheels = [- { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 },+[package.optional-dependencies]+mediapipe = [+ { name = "mediapipe" },][[package]]name = "sounddevice"-version = "0.5.3"+version = "0.5.5"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "cffi" },]-sdist = { url = "https://files.pythonhosted.org/packages/4e/4f/28e734898b870db15b6474453f19813d3c81b91c806d9e6f867bd6e4dd03/sounddevice-0.5.3.tar.gz", hash = "sha256:cbac2b60198fbab84533697e7c4904cc895ec69d5fb3973556c9eb74a4629b2c", size = 53465 }+sdist = { url = "https://files.pythonhosted.org/packages/2a/f9/2592608737553638fca98e21e54bfec40bf577bb98a61b2770c912aab25e/sounddevice-0.5.5.tar.gz", hash = "sha256:22487b65198cb5bf2208755105b524f78ad173e5ab6b445bdab1c989f6698df3", size = 143191, upload-time = "2026-01-23T18:36:43.529Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/73/e7/9020e9f0f3df00432728f4c4044387468a743e3d9a4f91123d77be10010e/sounddevice-0.5.3-py3-none-any.whl", hash = "sha256:ea7738baa0a9f9fef7390f649e41c9f2c8ada776180e56c2ffd217133c92a806", size = 32670 },- { url = "https://files.pythonhosted.org/packages/2f/39/714118f8413e0e353436914f2b976665161f1be2b6483ac15a8f61484c14/sounddevice-0.5.3-py3-none-macosx_10_6_x86_64.macosx_10_6_universal2.whl", hash = "sha256:278dc4451fff70934a176df048b77d80d7ce1623a6ec9db8b34b806f3112f9c2", size = 108306 },- { url = "https://files.pythonhosted.org/packages/f5/74/52186e3e5c833d00273f7949a9383adff93692c6e02406bf359cb4d3e921/sounddevice-0.5.3-py3-none-win32.whl", hash = "sha256:845d6927bcf14e84be5292a61ab3359cf8e6b9145819ec6f3ac2619ff089a69c", size = 312882 },- { url = "https://files.pythonhosted.org/packages/66/c7/16123d054aef6d445176c9122bfbe73c11087589b2413cab22aff5a7839a/sounddevice-0.5.3-py3-none-win_amd64.whl", hash = "sha256:f55ad20082efc2bdec06928e974fbcae07bc6c405409ae1334cefe7d377eb687", size = 364025 },+ { url = "https://files.pythonhosted.org/packages/1e/0a/478e441fd049002cf308520c0d62dd8333e7c6cc8d997f0dda07b9fbcc46/sounddevice-0.5.5-py3-none-any.whl", hash = "sha256:30ff99f6c107f49d25ad16a45cacd8d91c25a1bcdd3e81a206b921a3a6405b1f", size = 32807, upload-time = "2026-01-23T18:36:35.649Z" },+ { url = "https://files.pythonhosted.org/packages/56/f9/c037c35f6d0b6bc3bc7bfb314f1d6f1f9a341328ef47cd63fc4f850a7b27/sounddevice-0.5.5-py3-none-macosx_10_6_x86_64.macosx_10_6_universal2.whl", hash = "sha256:05eb9fd6c54c38d67741441c19164c0dae8ce80453af2d8c4ad2e7823d15b722", size = 108557, upload-time = "2026-01-23T18:36:37.41Z" },+ { url = "https://files.pythonhosted.org/packages/88/a1/d19dd9889cd4bce2e233c4fac007cd8daaf5b9fe6e6a5d432cf17be0b807/sounddevice-0.5.5-py3-none-win32.whl", hash = "sha256:1234cc9b4c9df97b6cbe748146ae0ec64dd7d6e44739e8e42eaa5b595313a103", size = 317765, upload-time = "2026-01-23T18:36:39.047Z" },+ { url = "https://files.pythonhosted.org/packages/c3/0e/002ed7c4c1c2ab69031f78989d3b789fee3a7fba9e586eb2b81688bf4961/sounddevice-0.5.5-py3-none-win_amd64.whl", hash = "sha256:cfc6b2c49fb7f555591c78cb8ecf48d6a637fd5b6e1db5fec6ed9365d64b3519", size = 365324, upload-time = "2026-01-23T18:36:40.496Z" },+ { url = "https://files.pythonhosted.org/packages/4e/39/a61d4b83a7746b70d23d9173be688c0c6bfc7173772344b7442c2c155497/sounddevice-0.5.5-py3-none-win_arm64.whl", hash = "sha256:3861901ddd8230d2e0e8ae62ac320cdd4c688d81df89da036dcb812f757bb3e6", size = 317115, upload-time = "2026-01-23T18:36:42.235Z" },][[package]]name = "starlette"-version = "0.49.3"+version = "0.52.1"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "anyio" },{ name = "typing-extensions", marker = "python_full_version < '3.13'" },]-sdist = { url = "https://files.pythonhosted.org/packages/de/1a/608df0b10b53b0beb96a37854ee05864d182ddd4b1156a22f1ad3860425a/starlette-0.49.3.tar.gz", hash = "sha256:1c14546f299b5901a1ea0e34410575bc33bbd741377a10484a54445588d00284", size = 2655031 }+sdist = { url = "https://files.pythonhosted.org/packages/c4/68/79977123bb7be889ad680d79a40f339082c1978b5cfcf62c2d8d196873ac/starlette-0.52.1.tar.gz", hash = "sha256:834edd1b0a23167694292e94f597773bc3f89f362be6effee198165a35d62933", size = 2653702, upload-time = "2026-01-18T13:34:11.062Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/a3/e0/021c772d6a662f43b63044ab481dc6ac7592447605b5b35a957785363122/starlette-0.49.3-py3-none-any.whl", hash = "sha256:b579b99715fdc2980cf88c8ec96d3bf1ce16f5a8051a7c2b84ef9b1cdecaea2f", size = 74340 },+ { url = "https://files.pythonhosted.org/packages/81/0d/13d1d239a25cbfb19e740db83143e95c772a1fe10202dda4b76792b114dd/starlette-0.52.1-py3-none-any.whl", hash = "sha256:0029d43eb3d273bc4f83a08720b4912ea4b071087a3b48db01b7c839f7954d74", size = 74272, upload-time = "2026-01-18T13:34:09.188Z" },][[package]]name = "tabulate"version = "0.9.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/ec/fe/802052aecb21e3797b8f7902564ab6ea0d60ff8ca23952079064155d1ae1/tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c", size = 81090 }+sdist = { url = "https://files.pythonhosted.org/packages/ec/fe/802052aecb21e3797b8f7902564ab6ea0d60ff8ca23952079064155d1ae1/tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c", size = 81090, upload-time = "2022-10-06T17:21:48.54Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/40/44/4a5f08c96eb108af5cb50b41f76142f0afa346dfa99d5296fe7202a11854/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f", size = 35252 },+ { url = "https://files.pythonhosted.org/packages/40/44/4a5f08c96eb108af5cb50b41f76142f0afa346dfa99d5296fe7202a11854/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f", size = 35252, upload-time = "2022-10-06T17:21:44.262Z" },][[package]]name = "threadpoolctl"version = "3.6.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", hash = "sha256:8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e", size = 21274 }+sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", hash = "sha256:8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e", size = 21274, upload-time = "2025-03-13T13:49:23.031Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638 },+ { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" },][[package]]name = "toml"version = "0.10.2"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253 }+sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253, upload-time = "2020-11-01T01:40:22.204Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload-time = "2020-11-01T01:40:20.672Z" },+]++[[package]]+name = "tomli-w"+version = "1.2.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/19/75/241269d1da26b624c0d5e110e8149093c759b7a286138f4efd61a60e75fe/tomli_w-1.2.0.tar.gz", hash = "sha256:2dd14fac5a47c27be9cd4c976af5a12d87fb1f0b4512f81d69cce3b35ae25021", size = 7184, upload-time = "2025-01-15T12:07:24.262Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588 },+ { url = "https://files.pythonhosted.org/packages/c7/18/c86eb8e0202e32dd3df50d43d7ff9854f8e0603945ff398974c1d91ac1ef/tomli_w-1.2.0-py3-none-any.whl", hash = "sha256:188306098d013b691fcadc011abd66727d3c414c571bb01b1a174ba8c983cf90", size = 6675, upload-time = "2025-01-15T12:07:22.074Z" },][[package]]name = "tqdm"-version = "4.67.1"+version = "4.67.3"source = { registry = "https://pypi.org/simple" }dependencies = [- { name = "colorama", marker = "platform_system == 'Windows'" },+ { name = "colorama", marker = "sys_platform == 'win32'" },]-sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737 }+sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", hash = "sha256:7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb", size = 169598, upload-time = "2026-02-03T17:35:53.048Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540 },+ { url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", hash = "sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf", size = 78374, upload-time = "2026-02-03T17:35:50.982Z" },][[package]]name = "typing-extensions"version = "4.15.0"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391 }+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614 },+ { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },][[package]]@@ -2177,18 +2187,18 @@ source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "typing-extensions" },]-sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949 }+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611 },+ { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },][[package]]name = "tzdata"-version = "2025.2"+version = "2025.3"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380 }+sdist = { url = "https://files.pythonhosted.org/packages/5e/a7/c202b344c5ca7daf398f3b8a477eeb205cf3b6f32e7ec3a6bac0629ca975/tzdata-2025.3.tar.gz", hash = "sha256:de39c2ca5dc7b0344f2eba86f49d614019d29f060fc4ebc8a417896a620b56a7", size = 196772, upload-time = "2025-12-13T17:45:35.667Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839 },+ { url = "https://files.pythonhosted.org/packages/c7/b0/003792df09decd6849a5e39c28b513c06e84436a54440380862b5aeff25d/tzdata-2025.3-py2.py3-none-any.whl", hash = "sha256:06a47e5700f3081aab02b2e513160914ff0694bce9947d6b76ebd6bf57cfc5d1", size = 348521, upload-time = "2025-12-13T17:45:33.889Z" },][[package]]@@ -2196,73 +2206,102 @@ name = "tzlocal"version = "5.3.1"source = { registry = "https://pypi.org/simple" }dependencies = [- { name = "tzdata", marker = "platform_system == 'Windows'" },+ { name = "tzdata", marker = "sys_platform == 'win32'" },]-sdist = { url = "https://files.pythonhosted.org/packages/8b/2e/c14812d3d4d9cd1773c6be938f89e5735a1f11a9f184ac3639b93cef35d5/tzlocal-5.3.1.tar.gz", hash = "sha256:cceffc7edecefea1f595541dbd6e990cb1ea3d19bf01b2809f362a03dd7921fd", size = 30761 }+sdist = { url = "https://files.pythonhosted.org/packages/8b/2e/c14812d3d4d9cd1773c6be938f89e5735a1f11a9f184ac3639b93cef35d5/tzlocal-5.3.1.tar.gz", hash = "sha256:cceffc7edecefea1f595541dbd6e990cb1ea3d19bf01b2809f362a03dd7921fd", size = 30761, upload-time = "2025-03-05T21:17:41.549Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/c2/14/e2a54fabd4f08cd7af1c07030603c3356b74da07f7cc056e600436edfa17/tzlocal-5.3.1-py3-none-any.whl", hash = "sha256:eb1a66c3ef5847adf7a834f1be0800581b683b5608e74f86ecbcef8ab91bb85d", size = 18026 },+ { url = "https://files.pythonhosted.org/packages/c2/14/e2a54fabd4f08cd7af1c07030603c3356b74da07f7cc056e600436edfa17/tzlocal-5.3.1-py3-none-any.whl", hash = "sha256:eb1a66c3ef5847adf7a834f1be0800581b683b5608e74f86ecbcef8ab91bb85d", size = 18026, upload-time = "2025-03-05T21:17:39.857Z" },][[package]]name = "urllib3"-version = "2.5.0"+version = "2.6.3"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185 }+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795 },+ { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },][[package]]name = "uvicorn"-version = "0.38.0"+version = "0.41.0"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "click" },{ name = "h11" },]-sdist = { url = "https://files.pythonhosted.org/packages/cb/ce/f06b84e2697fef4688ca63bdb2fdf113ca0a3be33f94488f2cadb690b0cf/uvicorn-0.38.0.tar.gz", hash = "sha256:fd97093bdd120a2609fc0d3afe931d4d4ad688b6e75f0f929fde1bc36fe0e91d", size = 80605 }+sdist = { url = "https://files.pythonhosted.org/packages/32/ce/eeb58ae4ac36fe09e3842eb02e0eb676bf2c53ae062b98f1b2531673efdd/uvicorn-0.41.0.tar.gz", hash = "sha256:09d11cf7008da33113824ee5a1c6422d89fbc2ff476540d69a34c87fab8b571a", size = 82633, upload-time = "2026-02-16T23:07:24.1Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/ee/d9/d88e73ca598f4f6ff671fb5fde8a32925c2e08a637303a1d12883c7305fa/uvicorn-0.38.0-py3-none-any.whl", hash = "sha256:48c0afd214ceb59340075b4a052ea1ee91c16fbc2a9b1469cca0e54566977b02", size = 68109 },+ { url = "https://files.pythonhosted.org/packages/83/e4/d04a086285c20886c0daad0e026f250869201013d18f81d9ff5eada73a88/uvicorn-0.41.0-py3-none-any.whl", hash = "sha256:29e35b1d2c36a04b9e180d4007ede3bcb32a85fbdfd6c6aeb3f26839de088187", size = 68783, upload-time = "2026-02-16T23:07:22.357Z" },][[package]]name = "websockets"-version = "15.0.1"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016 }-wheels = [- { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423 },- { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082 },- { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330 },- { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878 },- { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883 },- { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252 },- { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521 },- { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958 },- { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918 },- { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388 },- { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828 },- { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437 },- { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096 },- { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332 },- { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152 },- { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096 },- { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523 },- { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790 },- { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165 },- { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160 },- { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395 },- { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841 },- { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440 },- { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098 },- { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329 },- { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111 },- { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054 },- { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496 },- { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829 },- { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217 },- { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195 },- { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393 },- { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837 },- { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743 },+version = "16.0"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346, upload-time = "2026-01-10T09:23:47.181Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/f2/db/de907251b4ff46ae804ad0409809504153b3f30984daf82a1d84a9875830/websockets-16.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:31a52addea25187bde0797a97d6fc3d2f92b6f72a9370792d65a6e84615ac8a8", size = 177340, upload-time = "2026-01-10T09:22:34.539Z" },+ { url = "https://files.pythonhosted.org/packages/f3/fa/abe89019d8d8815c8781e90d697dec52523fb8ebe308bf11664e8de1877e/websockets-16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:417b28978cdccab24f46400586d128366313e8a96312e4b9362a4af504f3bbad", size = 175022, upload-time = "2026-01-10T09:22:36.332Z" },+ { url = "https://files.pythonhosted.org/packages/58/5d/88ea17ed1ded2079358b40d31d48abe90a73c9e5819dbcde1606e991e2ad/websockets-16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:af80d74d4edfa3cb9ed973a0a5ba2b2a549371f8a741e0800cb07becdd20f23d", size = 175319, upload-time = "2026-01-10T09:22:37.602Z" },+ { url = "https://files.pythonhosted.org/packages/d2/ae/0ee92b33087a33632f37a635e11e1d99d429d3d323329675a6022312aac2/websockets-16.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:08d7af67b64d29823fed316505a89b86705f2b7981c07848fb5e3ea3020c1abe", size = 184631, upload-time = "2026-01-10T09:22:38.789Z" },+ { url = "https://files.pythonhosted.org/packages/c8/c5/27178df583b6c5b31b29f526ba2da5e2f864ecc79c99dae630a85d68c304/websockets-16.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7be95cfb0a4dae143eaed2bcba8ac23f4892d8971311f1b06f3c6b78952ee70b", size = 185870, upload-time = "2026-01-10T09:22:39.893Z" },+ { url = "https://files.pythonhosted.org/packages/87/05/536652aa84ddc1c018dbb7e2c4cbcd0db884580bf8e95aece7593fde526f/websockets-16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d6297ce39ce5c2e6feb13c1a996a2ded3b6832155fcfc920265c76f24c7cceb5", size = 185361, upload-time = "2026-01-10T09:22:41.016Z" },+ { url = "https://files.pythonhosted.org/packages/6d/e2/d5332c90da12b1e01f06fb1b85c50cfc489783076547415bf9f0a659ec19/websockets-16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1c1b30e4f497b0b354057f3467f56244c603a79c0d1dafce1d16c283c25f6e64", size = 184615, upload-time = "2026-01-10T09:22:42.442Z" },+ { url = "https://files.pythonhosted.org/packages/77/fb/d3f9576691cae9253b51555f841bc6600bf0a983a461c79500ace5a5b364/websockets-16.0-cp311-cp311-win32.whl", hash = "sha256:5f451484aeb5cafee1ccf789b1b66f535409d038c56966d6101740c1614b86c6", size = 178246, upload-time = "2026-01-10T09:22:43.654Z" },+ { url = "https://files.pythonhosted.org/packages/54/67/eaff76b3dbaf18dcddabc3b8c1dba50b483761cccff67793897945b37408/websockets-16.0-cp311-cp311-win_amd64.whl", hash = "sha256:8d7f0659570eefb578dacde98e24fb60af35350193e4f56e11190787bee77dac", size = 178684, upload-time = "2026-01-10T09:22:44.941Z" },+ { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365, upload-time = "2026-01-10T09:22:46.787Z" },+ { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038, upload-time = "2026-01-10T09:22:47.999Z" },+ { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328, upload-time = "2026-01-10T09:22:49.809Z" },+ { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915, upload-time = "2026-01-10T09:22:51.071Z" },+ { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152, upload-time = "2026-01-10T09:22:52.224Z" },+ { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583, upload-time = "2026-01-10T09:22:53.443Z" },+ { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880, upload-time = "2026-01-10T09:22:55.033Z" },+ { url = "https://files.pythonhosted.org/packages/91/d6/7d4553ad4bf1c0421e1ebd4b18de5d9098383b5caa1d937b63df8d04b565/websockets-16.0-cp312-cp312-win32.whl", hash = "sha256:eaded469f5e5b7294e2bdca0ab06becb6756ea86894a47806456089298813c89", size = 178261, upload-time = "2026-01-10T09:22:56.251Z" },+ { url = "https://files.pythonhosted.org/packages/c3/f0/f3a17365441ed1c27f850a80b2bc680a0fa9505d733fe152fdf5e98c1c0b/websockets-16.0-cp312-cp312-win_amd64.whl", hash = "sha256:5569417dc80977fc8c2d43a86f78e0a5a22fee17565d78621b6bb264a115d4ea", size = 178693, upload-time = "2026-01-10T09:22:57.478Z" },+ { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364, upload-time = "2026-01-10T09:22:59.333Z" },+ { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039, upload-time = "2026-01-10T09:23:01.171Z" },+ { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323, upload-time = "2026-01-10T09:23:02.341Z" },+ { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975, upload-time = "2026-01-10T09:23:03.756Z" },+ { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203, upload-time = "2026-01-10T09:23:05.01Z" },+ { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653, upload-time = "2026-01-10T09:23:06.301Z" },+ { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920, upload-time = "2026-01-10T09:23:07.492Z" },+ { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255, upload-time = "2026-01-10T09:23:09.245Z" },+ { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689, upload-time = "2026-01-10T09:23:10.483Z" },+ { url = "https://files.pythonhosted.org/packages/f3/1d/e88022630271f5bd349ed82417136281931e558d628dd52c4d8621b4a0b2/websockets-16.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8cc451a50f2aee53042ac52d2d053d08bf89bcb31ae799cb4487587661c038a0", size = 177406, upload-time = "2026-01-10T09:23:12.178Z" },+ { url = "https://files.pythonhosted.org/packages/f2/78/e63be1bf0724eeb4616efb1ae1c9044f7c3953b7957799abb5915bffd38e/websockets-16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:daa3b6ff70a9241cf6c7fc9e949d41232d9d7d26fd3522b1ad2b4d62487e9904", size = 175085, upload-time = "2026-01-10T09:23:13.511Z" },+ { url = "https://files.pythonhosted.org/packages/bb/f4/d3c9220d818ee955ae390cf319a7c7a467beceb24f05ee7aaaa2414345ba/websockets-16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fd3cb4adb94a2a6e2b7c0d8d05cb94e6f1c81a0cf9dc2694fb65c7e8d94c42e4", size = 175328, upload-time = "2026-01-10T09:23:14.727Z" },+ { url = "https://files.pythonhosted.org/packages/63/bc/d3e208028de777087e6fb2b122051a6ff7bbcca0d6df9d9c2bf1dd869ae9/websockets-16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:781caf5e8eee67f663126490c2f96f40906594cb86b408a703630f95550a8c3e", size = 185044, upload-time = "2026-01-10T09:23:15.939Z" },+ { url = "https://files.pythonhosted.org/packages/ad/6e/9a0927ac24bd33a0a9af834d89e0abc7cfd8e13bed17a86407a66773cc0e/websockets-16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caab51a72c51973ca21fa8a18bd8165e1a0183f1ac7066a182ff27107b71e1a4", size = 186279, upload-time = "2026-01-10T09:23:17.148Z" },+ { url = "https://files.pythonhosted.org/packages/b9/ca/bf1c68440d7a868180e11be653c85959502efd3a709323230314fda6e0b3/websockets-16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19c4dc84098e523fd63711e563077d39e90ec6702aff4b5d9e344a60cb3c0cb1", size = 185711, upload-time = "2026-01-10T09:23:18.372Z" },+ { url = "https://files.pythonhosted.org/packages/c4/f8/fdc34643a989561f217bb477cbc47a3a07212cbda91c0e4389c43c296ebf/websockets-16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5e18a238a2b2249c9a9235466b90e96ae4795672598a58772dd806edc7ac6d3", size = 184982, upload-time = "2026-01-10T09:23:19.652Z" },+ { url = "https://files.pythonhosted.org/packages/dd/d1/574fa27e233764dbac9c52730d63fcf2823b16f0856b3329fc6268d6ae4f/websockets-16.0-cp314-cp314-win32.whl", hash = "sha256:a069d734c4a043182729edd3e9f247c3b2a4035415a9172fd0f1b71658a320a8", size = 177915, upload-time = "2026-01-10T09:23:21.458Z" },+ { url = "https://files.pythonhosted.org/packages/8a/f1/ae6b937bf3126b5134ce1f482365fde31a357c784ac51852978768b5eff4/websockets-16.0-cp314-cp314-win_amd64.whl", hash = "sha256:c0ee0e63f23914732c6d7e0cce24915c48f3f1512ec1d079ed01fc629dab269d", size = 178381, upload-time = "2026-01-10T09:23:22.715Z" },+ { url = "https://files.pythonhosted.org/packages/06/9b/f791d1db48403e1f0a27577a6beb37afae94254a8c6f08be4a23e4930bc0/websockets-16.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a35539cacc3febb22b8f4d4a99cc79b104226a756aa7400adc722e83b0d03244", size = 177737, upload-time = "2026-01-10T09:23:24.523Z" },+ { url = "https://files.pythonhosted.org/packages/bd/40/53ad02341fa33b3ce489023f635367a4ac98b73570102ad2cdd770dacc9a/websockets-16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b784ca5de850f4ce93ec85d3269d24d4c82f22b7212023c974c401d4980ebc5e", size = 175268, upload-time = "2026-01-10T09:23:25.781Z" },+ { url = "https://files.pythonhosted.org/packages/74/9b/6158d4e459b984f949dcbbb0c5d270154c7618e11c01029b9bbd1bb4c4f9/websockets-16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:569d01a4e7fba956c5ae4fc988f0d4e187900f5497ce46339c996dbf24f17641", size = 175486, upload-time = "2026-01-10T09:23:27.033Z" },+ { url = "https://files.pythonhosted.org/packages/e5/2d/7583b30208b639c8090206f95073646c2c9ffd66f44df967981a64f849ad/websockets-16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50f23cdd8343b984957e4077839841146f67a3d31ab0d00e6b824e74c5b2f6e8", size = 185331, upload-time = "2026-01-10T09:23:28.259Z" },+ { url = "https://files.pythonhosted.org/packages/45/b0/cce3784eb519b7b5ad680d14b9673a31ab8dcb7aad8b64d81709d2430aa8/websockets-16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:152284a83a00c59b759697b7f9e9cddf4e3c7861dd0d964b472b70f78f89e80e", size = 186501, upload-time = "2026-01-10T09:23:29.449Z" },+ { url = "https://files.pythonhosted.org/packages/19/60/b8ebe4c7e89fb5f6cdf080623c9d92789a53636950f7abacfc33fe2b3135/websockets-16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc59589ab64b0022385f429b94697348a6a234e8ce22544e3681b2e9331b5944", size = 186062, upload-time = "2026-01-10T09:23:31.368Z" },+ { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356, upload-time = "2026-01-10T09:23:32.627Z" },+ { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085, upload-time = "2026-01-10T09:23:33.816Z" },+ { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531, upload-time = "2026-01-10T09:23:35.016Z" },+ { url = "https://files.pythonhosted.org/packages/72/07/c98a68571dcf256e74f1f816b8cc5eae6eb2d3d5cfa44d37f801619d9166/websockets-16.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:349f83cd6c9a415428ee1005cadb5c2c56f4389bc06a9af16103c3bc3dcc8b7d", size = 174947, upload-time = "2026-01-10T09:23:36.166Z" },+ { url = "https://files.pythonhosted.org/packages/7e/52/93e166a81e0305b33fe416338be92ae863563fe7bce446b0f687b9df5aea/websockets-16.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:4a1aba3340a8dca8db6eb5a7986157f52eb9e436b74813764241981ca4888f03", size = 175260, upload-time = "2026-01-10T09:23:37.409Z" },+ { url = "https://files.pythonhosted.org/packages/56/0c/2dbf513bafd24889d33de2ff0368190a0e69f37bcfa19009ef819fe4d507/websockets-16.0-pp311-pypy311_pp73-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f4a32d1bd841d4bcbffdcb3d2ce50c09c3909fbead375ab28d0181af89fd04da", size = 176071, upload-time = "2026-01-10T09:23:39.158Z" },+ { url = "https://files.pythonhosted.org/packages/a5/8f/aea9c71cc92bf9b6cc0f7f70df8f0b420636b6c96ef4feee1e16f80f75dd/websockets-16.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0298d07ee155e2e9fda5be8a9042200dd2e3bb0b8a38482156576f863a9d457c", size = 176968, upload-time = "2026-01-10T09:23:41.031Z" },+ { url = "https://files.pythonhosted.org/packages/9a/3f/f70e03f40ffc9a30d817eef7da1be72ee4956ba8d7255c399a01b135902a/websockets-16.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:a653aea902e0324b52f1613332ddf50b00c06fdaf7e92624fbf8c77c78fa5767", size = 178735, upload-time = "2026-01-10T09:23:42.259Z" },+ { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598, upload-time = "2026-01-10T09:23:45.395Z" },+]++[[package]]+name = "wheel"+version = "0.46.3"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "packaging" },+]+sdist = { url = "https://files.pythonhosted.org/packages/89/24/a2eb353a6edac9a0303977c4cb048134959dd2a51b48a269dfc9dde00c8a/wheel-0.46.3.tar.gz", hash = "sha256:e3e79874b07d776c40bd6033f8ddf76a7dad46a7b8aa1b2787a83083519a1803", size = 60605, upload-time = "2026-01-22T12:39:49.136Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/87/22/b76d483683216dde3d67cba61fb2444be8d5be289bf628c13fc0fd90e5f9/wheel-0.46.3-py3-none-any.whl", hash = "sha256:4b399d56c9d9338230118d705d9737a2a468ccca63d5e813e2a4fc7815d8bc4d", size = 30557, upload-time = "2026-01-22T12:39:48.099Z" },]