ddalab 1.2.11__py3-none-win_amd64.whl

ddalab-1.2.11.dist-info/METADATA

@@ -0,0 +1,277 @@
+Metadata-Version: 2.4
+Name: ddalab
+Version: 1.2.11
+Summary: DDALAB desktop application and command-line interface
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/sdraeger/DDALAB
+Project-URL: Documentation, https://github.com/sdraeger/DDALAB/tree/main/packages/ddalab
+Project-URL: Repository, https://github.com/sdraeger/DDALAB
+Project-URL: Issues, https://github.com/sdraeger/DDALAB/issues
+Requires-Python: <3.13,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: PySide6==6.8.2.1
+Requires-Dist: requests<3,>=2.32.0
+Requires-Dist: urllib3<2
+Requires-Dist: numpy==1.26.4
+Requires-Dist: matplotlib==3.10.8
+Requires-Dist: scipy==1.13.1
+Requires-Dist: scikit-learn==1.5.2
+Requires-Dist: mne==1.8.0
+Requires-Dist: defusedxml<1,>=0.7
+Requires-Dist: pymatreader<1,>=0.0.32
+Requires-Dist: mffpy<1,>=0.10
+Requires-Dist: nibabel==5.3.3
+Requires-Dist: pyxdf==1.16.8
+Requires-Dist: pynwb==2.8.3
+Requires-Dist: packaging<25,>=24
+
+# DDALAB
+
+`ddalab` is the unified Python package for DDALAB.
+
+It ships:
+
+- the command-line interface
+- the Qt desktop application
+- the shared local runtime and dataset readers
+- the bundled `dda-rs` backend binary used for local DDA analysis
+
+## Entry Points
+
+Installing this package provides:
+
+- `ddalab`
+- `ddalab-cli`
+- `ddalab-gui`
+
+Use `ddalab open` to open the desktop application. Other `ddalab` commands use
+the command-line interface. `ddalab gui` remains an alias for `ddalab open`,
+and `ddalab-gui` launches the application directly.
+
+## Install
+
+```bash
+python -m pip install ddalab
+ddalab open
+```
+
+For a source checkout:
+
+```bash
+cd packages/ddalab
+python -m pip install .
+```
+
+Published wheels and desktop installers bundle the local `dda-rs` backend, so DDA works offline without a separate network service.
+
+For editable or source installs, local DDA analysis also requires a working Rust toolchain with `cargo` so the bundled `dda-rs` binary can be built for your platform.
+
+## CLI Examples
+
+```bash
+ddalab health
+ddalab dataset info --file data/MG100_Seizure1.edf
+ddalab dda info --json
+ddalab dda validate data/MG100_Seizure1.edf --json
+ddalab dda run data/MG100_Seizure1.edf --channels 0 1 2 --variants ST SY --end 30
+ddalab dda run data/MG100_Seizure1.edf --channels 0 1 2 --variants ST --device cuda
+ddalab dda batch --bids-dir data/ds003029 --variants ST --continue-on-error
+```
+
+CPU execution is the default. The desktop DDA setup and CLI accept CUDA on
+systems with an NVIDIA driver and cuBLAS runtime; `cuda:N` selects a specific
+GPU. Analyses that use Rust-only CCD extensions continue those extension
+computations on the CPU.
+
+## Python DDA Estimators
+
+The bundled Python backend includes scalar estimators for derivative-form and
+weak-form DDA. Derivative-form DDA builds delayed polynomial features
+`Phi(t)` and regresses a numerical derivative of `x(t)` on those features.
+Weak-form DDA uses the same delayed polynomial dictionary, but fits integrated
+increments instead:
+
+```text
+x(t + Delta) - x(t) ~= integral_t^{t+Delta} Phi(s) ds @ beta
+```
+
+This avoids pointwise derivative estimation and can be preferable when
+observation noise would be amplified by finite differences. Coefficients remain
+on the same differential-equation scale as derivative-form DDA because both the
+response and design matrix are integrated over the same window.
+
+```python
+from ddalab_app.backend.dda import DerivativeDDA, WeakFormDDA
+
+vanilla = DerivativeDDA(degree=3, delays=[0], derivative="finite_difference")
+vanilla.fit(x, dt=0.01)
+
+weak = WeakFormDDA(
+    degree=3,
+    delays=[0],
+    integration_window=9,
+    stride=1,
+    quadrature="trapezoid",
+    regression="ridge",
+    ridge_alpha=1e-6,
+    standardize_features=True,
+)
+weak.fit(x, dt=0.01)
+print(weak.term_names_)
+print(weak.coefficients_)
+```
+
+`integration_window` and `stride` are specified in samples. Use
+`integration_window_seconds` or `stride_seconds` with `dt`/`sample_rate` when
+time-based settings are more convenient. The default weak-form window is
+conservative: half of the smallest positive delay, with a lower bound of three
+samples, or five samples for nondelayed scalar systems. Too-small windows behave
+more like derivative DDA; too-large windows can blur fast dynamics.
+
+The available quadrature rules are `trapezoid`, `left_rectangle`,
+`right_rectangle`, `midpoint`, and `simpson` when SciPy is available.
+`trapezoid` is the default because it is the natural continuous-time weak-form
+choice for sampled trajectories. `left_rectangle` can match an Euler-stepped
+simulator more closely and is useful as a discretization diagnostic, but it is
+not the recommended default for continuous-time estimation.
+
+Weak-form DDA does not universally dominate derivative DDA. It trades derivative
+noise sensitivity for integration-window bias. In practice, choose
+`integration_window` on a held-out validation interval by minimizing weak-form
+interval prediction error, then report the selected-window result. Oracle-best
+windows, selected using known synthetic coefficients, are useful for experiments
+but should be treated only as upper bounds.
+
+For noisy or ill-conditioned windows, the recommended weak-form setting is
+`regression="ridge"` with `standardize_features=True`. Feature standardization is
+used only internally for numerical conditioning; exposed coefficients are
+back-transformed to the original feature scale, so they remain comparable to
+ordinary derivative-form DDA coefficients.
+
+## Weak-Form Sparse Additive DDA
+
+The currently supported reliable Python estimator is polynomial `WeakFormDDA`.
+`SparseAdditiveWeakFormDDA` is experimental infrastructure for nonlinear
+main-effect delay discovery; use it for method development and diagnostics, not
+as a replacement for polynomial weak-form DDA in production analyses.
+
+Fixed polynomial dictionaries are interpretable but can be brittle when the
+true delayed response is saturating, threshold-like, or otherwise smooth but not
+well approximated by low-order monomials. `SparseAdditiveWeakFormDDA` replaces
+polynomial terms with cubic B-spline response functions over candidate delays:
+
+```text
+dx/dt = c + sum_tau f_tau(x(t - tau))
+```
+
+Each response function is fit in weak form by integrating spline basis functions
+over the same interval used for the observed increment. The first implementation
+is scalar and main-effect only; it does not yet fit pairwise delay surfaces.
+Delay selection is statistically meaningful only with group sparsity, because
+all spline basis functions for one delay must enter or leave the model together.
+Neighboring candidate delays can also be nearly duplicate predictors, so delay
+dictionary thinning and state-coverage diagnostics are part of the estimator.
+
+```python
+from ddalab_app.backend.dda import (
+    SparseAdditiveWeakFormDDA,
+    stability_select_sparse_additive_weak_form,
+)
+
+model = SparseAdditiveWeakFormDDA(
+    candidate_delays=[0, 10, 11, 24, 25, 40],
+    n_knots=7,
+    spline_degree=3,
+    integration_window=9,
+    stride=1,
+    quadrature="trapezoid",
+    regression="group_lasso",
+    group_lasso_alpha=0.004,
+    ridge_alpha=1e-6,
+    standardize_features=True,
+    thin_delays=True,
+    max_delay_correlation=0.98,
+)
+model.fit([x_trial_1, x_trial_2, x_trial_3], dt=0.01)
+print(model.selected_delays_)
+print(model.group_strengths_)
+print(model.delay_block_correlation_)
+print(model.state_coverage_)
+
+grid, effect = model.effect_curves_[10]
+```
+
+`fit` accepts either one scalar trajectory or a list of scalar trajectories. For
+list input, spline bases are shared across trajectories and weak-form windows
+are built within each trajectory only, never across trajectory boundaries.
+
+Delay ranking is based on the L2 norm of each delay-specific spline coefficient
+block. With `regression="group_lasso"`, inactive delay blocks can be driven to
+zero directly. For more conservative delay selection, use stability selection
+with null calibration:
+
+```python
+scores = stability_select_sparse_additive_weak_form(
+    [x_trial_1, x_trial_2, x_trial_3],
+    dt=0.01,
+    candidate_delays=model.candidate_delays_,
+    integration_window=9,
+    regression="group_lasso",
+    group_lasso_alpha=0.004,
+    n_repeats=20,
+    null_repeats=10,
+    calibrate=True,
+)
+print(scores.selection_frequency)
+print(scores.null_selection_frequency)
+print(scores.calibrated_selected_delays)
+```
+
+Prefer polynomial weak-form DDA when a low-order dictionary is scientifically
+meaningful and coefficient-level interpretation is the primary output. Prefer
+sparse additive weak-form DDA only when the main question is whether a small set
+of candidate delays has smooth nonlinear influence and the shape of that
+influence is itself informative. Current limitations are scalar input, main
+effects only, sensitivity to candidate-delay collinearity, dependence on broad
+state coverage, and validation-dependent choices of spline, group penalty, and
+stability thresholds.
+
+## Choosing Between WeakFormDDA and SparseAdditiveWeakFormDDA
+
+Use `WeakFormDDA` as the default estimator when the goal is robust recovery of
+polynomial DDA coefficients or when the analysis must be stable without
+additional model-selection diagnostics. It is the reliable general-purpose
+Python estimator.
+
+Use `SparseAdditiveWeakFormDDA` only as an experimental nonlinear-delay
+estimator. A defensible sparse-additive analysis should use group-lasso delay
+blocks, candidate-delay thinning, stability selection, null calibration, and
+state-coverage checks. Sparse-additive delay selections should not be trusted
+when instantaneous null diagnostics select delayed terms, even if interval
+prediction error is competitive. The current estimator also cannot represent
+pairwise or interacting nonlinear delayed effects; those require a future
+pairwise-surface model rather than the current main-effect spline model.
+
+## Desktop Development
+
+```bash
+cd packages/ddalab
+./start.sh
+```
+
+The script provisions a local virtual environment, installs the unified package in editable mode, and launches the Qt application.
+
+The desktop application uses a Qt Quick/QML workbench. Waveform and DDA-result
+plots use viewport-aware, cached Qt Quick scene-graph surfaces; there is no
+separate QWidget rendering mode.
+
+See [ARCHITECTURE.md](ARCHITECTURE.md) for the desktop boundaries and data flow.
+
+If you are working from source, `./start.sh` expects `cargo` to be available so it can build or refresh the bundled `dda-rs` runtime.
+
+## Smoke Test
+
+```bash
+cd packages/ddalab
+./start.sh --smoke-test
+```

ddalab-1.2.11.dist-info/RECORD

@@ -0,0 +1,116 @@
+ddalab_app/__init__.py,sha256=YKRhpInhcIqFLhs3fSFrUy_o9HMgwFO3lPDxXG4363k,103
+ddalab_app/__main__.py,sha256=Jk9YMe4tVRadNwNcM9mxdW1_tN_pkg26sis3mkW00kk,88
+ddalab_app/cli_main.py,sha256=1UlDcblfWrYsuW_CmqaiF0w0vywCkK3HdRyYvJbQPGs,695
+ddalab_app/gui_main.py,sha256=_8jOoBTTh3QVRR5dSGyfdtwtuCPojDHD4ddRybJhmuQ,2496
+ddalab_app/runtime_binary_names.py,sha256=WwNOibNAYTXYUfOQYX52FAtZOoQMtTHjKFCJurszXH4,232
+ddalab_app/runtime_paths.py,sha256=4p3bzh_-XdFMKrU7qfJwWK58JqTJUpqmQWAIa0jZpt8,2984
+ddalab_app/update_manager.py,sha256=8wk_L_XW2WZC6pC1UvGr9wvXZTAvN42cp_kJaKxy1Fo,16212
+ddalab_app/version.py,sha256=wr0yVXCX4U6wjc3AcG1itFbxKxKRePJCNBF5ZYM8PjI,1156
+ddalab_app/app/__init__.py,sha256=Nl-gYPu5IVo422-S41L_qbnJMXULzeUlL33E2WDy4Wo,394
+ddalab_app/app/core/__init__.py,sha256=LBHvoYmCg4kz2wVRNj692IFMjqEuJ3Y-VTOdz7uBdCs,33
+ddalab_app/app/core/analysis_input.py,sha256=8gyK65SARoZi48pqcNLCawzOxhULgXKQbYQZGDHtIk8,1287
+ddalab_app/app/core/snapshot_payload.py,sha256=yu_QBDm_3H4gI9_qNa-UMXSivl_8RUU-uDgGCnMPFjo,2778
+ddalab_app/app/integrations/__init__.py,sha256=hV2ircjsAHrXw2AKsMlFMNSq4pAP09Gn5QBkbQyNhHA,48
+ddalab_app/app/integrations/cdr.py,sha256=EwQkZYBEgWo21eEgKACp44suJdWPurdBo67YYijHrQs,10406
+ddalab_app/app/integrations/cdr_simulation.py,sha256=rlyMabtNOIzWvISjFSUsoZHcyipKJt1S-7TYVpKltco,6713
+ddalab_app/app/integrations/dda_export_utils.py,sha256=LO22y84MibdHfwq6Pdu4pHZaXPFT5xB7gmt8A8h50BU,14706
+ddalab_app/app/runtime/__init__.py,sha256=LX6v7hqHEUCcFIanbkd6faYDpHkF4sme-TFgZHFUiC4,48
+ddalab_app/app/runtime/perf_logging.py,sha256=Q_OXeCqHNtCjTSAwCqK2kLMMZD0gu_AL1DwJzovFdOI,2277
+ddalab_app/app/runtime/runtime_logging.py,sha256=gPrFqC1-tMLXk2pvs7oWUC3ayE5fF2FSFk4-CrYq7q8,7792
+ddalab_app/app/workbench/__init__.py,sha256=yBvhosFpyzoveWVbN610c8Yb7G2hEPaWQj-5Qgz5y7A,139
+ddalab_app/app/workbench/controller.py,sha256=V640Fj6P8yTxzLuZQl2TwyuiqxLNaj4Kktxf1Xn-HGk,72893
+ddalab_app/app/workbench/models.py,sha256=hwcJbfSLI1ltEqIxiZOXhIY8hQyaeBGD7ksY4Yn_AR8,3985
+ddalab_app/app/workbench/runtime.py,sha256=ZXn1z6DVmN1H8D2oiM6z9cFHwejNc5cEyhqq_oQ6S8s,1440
+ddalab_app/app/workbench/tasks.py,sha256=O1P9IwAWo0dhBjHvhvhpWeA_rF71bOtcPdedThOtRy0,1580
+ddalab_app/assets/fonts/ibm_plex_sans_medium.ttf,sha256=MxyGOddZiyzeYqkRpx2xleMMtlXNa98uMkp-mElV-Qc,202460
+ddalab_app/assets/fonts/ibm_plex_sans_regular.ttf,sha256=l13No32A8Djc0UPCLjPKLZegzFqSmqzhx0kVOw_hr6U,200500
+ddalab_app/assets/fonts/ibm_plex_sans_semibold.ttf,sha256=ogyvgoYCOmp6heQLHSpK6fw-Ox-e2o9MVC3UmGr2e7E,202632
+ddalab_app/assets/icons/icon.icns,sha256=-jt9ZDzQJZ2lmiWe13uVbZKYxBhCWgBrBOuyb5D6x-0,719367
+ddalab_app/assets/icons/icon.ico,sha256=pFdwmDiX4Y_w_F40aH5El-AWb0MdoP5fvDe54T3UA20,99678
+ddalab_app/assets/icons/icon.png,sha256=gcEZiLqUi0i3xiKOOci7I2Mvx6zhxAzPivzTw7ztr0Y,32619
+ddalab_app/assets/icons/icon.svg,sha256=26OUw8DJz1vrL9uTugHFztGqM8RNPEL4zHAgJPYkpcw,1867
+ddalab_app/backend/__init__.py,sha256=EjzlFTQrjHgu5TxV-AZOpLNQsmvXfTvezYIg_4WMN04,254
+ddalab_app/backend/contracts.py,sha256=wV1zecq0M7wP_OL0URTCIB0tPIVCJcyjN6Pc-C5xw1o,4811
+ddalab_app/backend/dda/__init__.py,sha256=B9pvY05NBZEIUMg9n_-o7Gf7tOIaeJEuG3Jh8gobcuQ,2151
+ddalab_app/backend/dda/engine.py,sha256=PVhgb3dHBcVA8DjabBuUdFBFEF4-I-sxLjxnKuzYE0U,28612
+ddalab_app/backend/dda/motifs.py,sha256=oPq94AGZoc_5JxkpjDO400ro185FtDDYiJJAjp8Omeg,4698
+ddalab_app/backend/dda/scalar.py,sha256=Iau1Ljaf2xoz1a2NwtuMDSySlN85QQC42pF2_8l66RI,24132
+ddalab_app/backend/dda/sidecar.py,sha256=87BmQoBdC11yW1sRAvhGwevSXcPzrby4QC2_74vct9o,7874
+ddalab_app/backend/dda/sparse.py,sha256=TKgFDRW2pX9en0K2FxXB9Js84U4z-cbj-GBK4t_HZdI,36904
+ddalab_app/backend/local/__init__.py,sha256=VgaxGkVdpaktLe4mJEB_ypf6rHuR_NlUY6W3Ee3TJe0,234
+ddalab_app/backend/local/client.py,sha256=_WBNcQPWbDA_bHcWfKhXDQfUio3N_aX_EPOfjm2hZc4,9102
+ddalab_app/backend/local/dda.py,sha256=0TWzrt-3d_8k4QAxOYbVl6fCrcyp8J2l_A--noFNjjI,40108
+ddalab_app/backend/local/filesystem.py,sha256=yS3uwmf5Aojj3HvZJ3jw0LKHbILAN3PONAGmp29oYJU,4641
+ddalab_app/backend/local/results.py,sha256=pt6BlDByQhkhXXNjxzQjm9wvIFf-SK7fEb9-STrbsmY,9143
+ddalab_app/backend/local/runtime.py,sha256=fvqAlB-lLtMkIQeTa13riqWvi4ylwKGoOVabFLHoyMM,5647
+ddalab_app/backend/readers/__init__.py,sha256=QlnWBE98mlNzXPzA_jOLEjlZKx1wRh_BeGFh884MRiY,299
+ddalab_app/backend/readers/common.py,sha256=pn3BbzsK1MwPy_RGRb-_00kfgUb49VnUWeH6RF9xy1c,8929
+ddalab_app/backend/readers/delimited.py,sha256=ktEHhytsi-Ch8a_j9x2cNvGZbcottDr7zeqqDpWzwes,10728
+ddalab_app/backend/readers/local.py,sha256=tQN8aN9tPZNDhkjQIsZ-xE-FljQ6ZCWZIkg1rZNhrRs,2587
+ddalab_app/backend/readers/mne.py,sha256=c_BuDmhKs7_a8XX3G1zl0d8Qml_5T86_6zK5QK62_oY,6295
+ddalab_app/backend/readers/nifti.py,sha256=1YfiQoRz351qF-RsUpFLE-zhzAiqywBI3j_2OmPXbGA,8173
+ddalab_app/backend/readers/nwb.py,sha256=zNamTE5jDjMDGiekT7CMBNsH1NyO_ssUx7J619ZGrrA,6727
+ddalab_app/backend/readers/xdf.py,sha256=PkNnad2YN1ssFX7uSPbCGS9P8i7Bap9eZQaGUHObkps,7631
+ddalab_app/backend/services/__init__.py,sha256=QJv9t4bmQbSI3k4a-xPr94FLeFpTythkN-zDAyrDx8U,253
+ddalab_app/backend/services/ica.py,sha256=9N0v8GvT10ZIB9KIqBrqT97qO5e-60H5voJK34NUhLk,5805
+ddalab_app/backend/services/nsg.py,sha256=Z0lsFm2GjALIWq2Fky4y9pIz6DchQUYgBsBI4S0-L-0,25572
+ddalab_app/backend/services/openneuro.py,sha256=xOVnMp2mOu_rKxoP_I_1QZ8ip71nqB79Sj8FQtBLWMg,4658
+ddalab_app/cli/__init__.py,sha256=bFFVE9jRKczNy4HhmegWoC6KOL_Nrej-ag37DAIDzaA,36
+ddalab_app/cli/commands.py,sha256=UTSzEE18mrD3AKceruxK6E_p8bbC6pLR4cSoufX5Jms,11275
+ddalab_app/cli/constants.py,sha256=lvczhH-2rL-w66USvvWWqxvVk3ox4GxAFnMgPPZ46Gk,1379
+ddalab_app/cli/parser.py,sha256=8UMlqk4rYIstnzCaKVS32uSLk12PE5fDF47dOtnfjEE,10279
+ddalab_app/cli/plot_style.py,sha256=34hKnC4bg34r1KlKOqesP28Kv0SjFAZwmklJje9LTpQ,1168
+ddalab_app/cli/runtime.py,sha256=gO-A0bFQINCc-krBjr2wmTTK0b8LAgckYcK6qPxOj6o,18200
+ddalab_app/domain/__init__.py,sha256=Hi8XD2DicapE64k3jc2oAxGs3-dInkmp-f03NDKEfmk,60
+ddalab_app/domain/file_types.py,sha256=pLObJBAniDijJrceXQjzX1VQ4XgUgtpQX8cvXXMlZYk,7471
+ddalab_app/domain/models.py,sha256=N9xYT7z02sZiPW2oYkBb1_-6_xghjWtq2ELxVT1yqKA,31852
+ddalab_app/persistence/__init__.py,sha256=DKQN6zQTekOZh8SHTKGRZ9RfvAzgk2jg3afXGmGRLNw,68
+ddalab_app/persistence/state_db.py,sha256=jDFhyBI8tdxnksHAvTwpUc4UxVUr8mjfYHLHc7Abkjc,35376
+ddalab_app/runtime/bin/ddalab-backend.exe,sha256=VgUkXxRHuq9Uy5EilWJtz5tiVGOJOJ8ZZ5uV7qhFGrg,2724864
+ddalab_app/ui/__init__.py,sha256=Z2CetSy5ceJDCuajBd3ESYcY3Ftn6kaj0yVtTHSU0J0,245
+ddalab_app/ui/plot_benchmarks.py,sha256=2SA7a28uLkFQ4ImZnz-hLLvVnNO8dT2h73e4VM24U5U,5216
+ddalab_app/ui/plot_data.py,sha256=wXjI0pJS9_SFPmTRfowjJ1gZz8IrPEzn0ODljGze25Q,2072
+ddalab_app/ui/plot_data_common.py,sha256=wGU7emw61eP9-VkqHA89D7JPXsim2ejMjMQtaV2rg-o,4215
+ddalab_app/ui/plot_heatmap_data.py,sha256=2Lw8rOYIs32lKFfYxjuQbvpunWK3VLdWiyfJTpgnE8s,2775
+ddalab_app/ui/plot_layers.py,sha256=L43iS5TpktldOKzJf9hZlViwd3d8F9vuEfLjbwUzruk,257
+ddalab_app/ui/plot_matrix_data.py,sha256=RQ5YhIVQM-S3kpRVyjl52K-gdvkh1TsIwIRURxopjU0,11573
+ddalab_app/ui/plot_waveform_data.py,sha256=rFo93LLL6GCsTfVFln7oLtWmQQXpuKVVqhQgCE308Mc,20940
+ddalab_app/ui/qt_plot_renderer.py,sha256=RhUzNq-Ku2fa3GJCP7fOZHqvuSiJUn7Vkfe71aFC-3Y,6493
+ddalab_app/ui/quick_plot_surface.py,sha256=U29C3Zq74rMVIDrGHF6AWzT-f3YcsNRllX35ZfryMMI,26015
+ddalab_app/ui/quick_waveform_surface.py,sha256=CM2ho5bYdjg9wSCYg0v76pi0c7j-DgupktpxNJxDmhg,21747
+ddalab_app/ui/render_cache.py,sha256=E6OZw4v5rN-bwje5PK3P3YxO0zfePytW3XjZJIMQ_Xo,903
+ddalab_app/ui/style.py,sha256=dTOQL_3yVjeW2-uvSX3qfPO8d_0pZplFava_Y9F9h_s,6689
+ddalab_app/ui/qml/QuickPlotSurface.qml,sha256=Y_N0abEpOeJLAIV34gv1MFdhuFfPsuyzafyiGi2aPH0,9637
+ddalab_app/ui/qml/QuickWaveformSurface.qml,sha256=yQYUdVHwQ2x6xjILkiCXEXJA6pPRVGDibivuaUvq7DM,11934
+ddalab_app/ui/qml/__init__.py,sha256=7aBq1lfxIG5FLTuCLWhDQIRB6Q0QiZBmc6yaH2vH9XQ,72
+ddalab_app/ui/qml/workbench/Main.qml,sha256=H_gCWdtwxJSaScJdCYRxqh4DaWlJdvn3MGd8rlC5i78,13340
+ddalab_app/ui/qml/workbench/__init__.py,sha256=DPkO2mOqDlO2axsS3Of4wqENeO9q6XxR6U6zmibq8Gc,37
+ddalab_app/ui/qml/workbench/components/ActivitySpinner.qml,sha256=EdapSc4n3XwVbkVrm2pUEKGkopennzjw5o3Is8caCR0,785
+ddalab_app/ui/qml/workbench/components/AnalysisInputSummary.qml,sha256=uKHgGVvT83ThtWFFi0biwNuzAOaYQIfnktOnvRnvCBs,2554
+ddalab_app/ui/qml/workbench/components/AnalysisInspector.qml,sha256=4bEVIVX2JszT4zl9NfALl501IItaCBKsVLXAY0065_s,7616
+ddalab_app/ui/qml/workbench/components/CdrHeatmap.qml,sha256=ZZReFJI3UXURKxekyv_6np57aES_Oi-9n-rBIRO8rXQ,3013
+ddalab_app/ui/qml/workbench/components/CdrLineChart.qml,sha256=a2BRmfRZOfykBpdh6WBd6Hy8t9lh4KvdN-k_Wvi7apU,8200
+ddalab_app/ui/qml/workbench/components/CdrResultsView.qml,sha256=SmOFDKu3NdJwfL5Fp8QAmSmGR_XvafykTU1uVT__s44,2433
+ddalab_app/ui/qml/workbench/components/InspectorPanel.qml,sha256=8XCeusls7G0mQM0wSf3ykU-gkmqG02Kv07D-jmqbMiY,3260
+ddalab_app/ui/qml/workbench/components/LibraryRail.qml,sha256=RhZYuPonGMdfpX-imFPglB7-aXT-YR_2x6ImazGS5Hc,5016
+ddalab_app/ui/qml/workbench/components/LoadingOverlay.qml,sha256=pwu39ayNT6EiLZK5d_NtvbGMFETPbFZ8NMG4yH322rU,704
+ddalab_app/ui/qml/workbench/components/NavButton.qml,sha256=ziVw23WLROYBJpVpAwoIo_llAeJfvVnyqoVNej6X6ac,886
+ddalab_app/ui/qml/workbench/components/ResultHistoryList.qml,sha256=axLmWhCBuj6fxL5nmKdNX6MEQYsDnGTI9xUZ1-Kg6yY,1932
+ddalab_app/ui/qml/workbench/components/ResultsInspector.qml,sha256=toKlTL7Ibpzv4OIaX3TuyCCty0t_BQJ8nqeF95MAEj8,4860
+ddalab_app/ui/qml/workbench/components/SectionLabel.qml,sha256=5D78qV3yoxqpxuV1teRgAvCfMpfRmj0KzrhaTVxaZog,174
+ddalab_app/ui/qml/workbench/components/SettingsInspector.qml,sha256=HkVR4c1EdaoABWN5aL8mJYErDKOGQWJKqKdhYe7Fo5o,4050
+ddalab_app/ui/qml/workbench/components/Toggle.qml,sha256=jJk1kKxUsEvhtg3KSDCLAMStyXNBBO4tCv5xTPRsaJA,1144
+ddalab_app/ui/qml/workbench/components/WorkbenchButton.qml,sha256=kycnNl2WyoeBP7eUJd6poM-sQeWxZsThYCsbyFvfgtQ,1606
+ddalab_app/ui/qml/workbench/components/WorkbenchField.qml,sha256=fGXJpjsuNauy10DFj1w4tEhaRp0oactLnqUgy5rQyfQ,561
+ddalab_app/ui/qml/workbench/components/WorkspaceInspector.qml,sha256=4w4USbJOTslm1sX_x8osuFEDmwFfBcK4dpAMa27XJ94,4035
+ddalab_app/ui/qml/workbench/components/__init__.py,sha256=NgYAbZxtCPTuzNbWu6NNrYhie1c8V6LiXHhXYBfQNpc,37
+ddalab_app/ui/qml/workbench/pages/AnalysisPage.qml,sha256=C2P9vBMr3xtesYYQ5u69RJ09AHk621x-DC6EJU5L3z0,9274
+ddalab_app/ui/qml/workbench/pages/ResultsPage.qml,sha256=1yo3gzn0DFlpLYbbmhB0m6hmcXsuMugRtTBqv6wsRDc,10416
+ddalab_app/ui/qml/workbench/pages/SettingsPage.qml,sha256=i-1CvtfftqVedu8LWEzfEpLdavdn_c-AtiIp_lwy4FY,1293
+ddalab_app/ui/qml/workbench/pages/WorkspacePage.qml,sha256=XL3kaVNNrhaJjpW0Aa1olfaoKhRdstgMdCP6Ro0G8jU,9563
+ddalab_app/ui/qml/workbench/pages/__init__.py,sha256=GIQ00j6UixZn_KzluWKExcWBD8NkYTFIcPEFkZTGTzY,31
+ddalab-1.2.11.dist-info/METADATA,sha256=kEm1HG88h_J28P7fuNXOPX7b_l0_wQ5Qd7RtFK-wGpk,10755
+ddalab-1.2.11.dist-info/WHEEL,sha256=Zx98gwb_dQKckJK3HEOVKnxxD52EfU_PXDG_usMJ2ng,98
+ddalab-1.2.11.dist-info/entry_points.txt,sha256=G1j5iVXh-26MI9fcJFTIa5QTWOZeR6s-8H_UQjSUEzc,128
+ddalab-1.2.11.dist-info/top_level.txt,sha256=o4GDxaoK1ej70LrJjAx2U_XqlkZkqZB2MVmq75likkw,11
+ddalab-1.2.11.dist-info/RECORD,,

ddalab-1.2.11.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64
+

ddalab-1.2.11.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+ddalab = ddalab_app.__main__:main
+ddalab-cli = ddalab_app.__main__:main
+ddalab-gui = ddalab_app.gui_main:main

ddalab-1.2.11.dist-info/top_level.txt

@@ -0,0 +1 @@
+ddalab_app

ddalab_app/__init__.py

@@ -0,0 +1,5 @@
+"""DDALAB Qt prototype."""
+
+from .version import get_app_version
+
+__version__ = get_app_version()

ddalab_app/__main__.py

@@ -0,0 +1,4 @@
+from .cli_main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

ddalab_app/app/__init__.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+__all__ = ["WorkbenchController", "build_workbench"]
+
+
+def __getattr__(name: str):
+    if name in __all__:
+        from .workbench import WorkbenchController, build_workbench
+
+        return {
+            "WorkbenchController": WorkbenchController,
+            "build_workbench": build_workbench,
+        }[name]
+    raise AttributeError(name)

ddalab_app/app/core/__init__.py

@@ -0,0 +1 @@
+"""Shared app-level helpers."""

ddalab_app/app/core/analysis_input.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import Optional
+
+
+def parse_time_bounds(
+    start_text: str,
+    end_text: str,
+    *,
+    label: str,
+    default_start: Optional[float] = 0.0,
+) -> tuple[Optional[float], Optional[float]]:
+    start = _parse_optional_seconds(
+        start_text,
+        field_name=f"{label} start",
+        default=default_start,
+    )
+    end = _parse_optional_seconds(
+        end_text,
+        field_name=f"{label} end",
+        default=None,
+    )
+    if start is not None and start < 0:
+        raise ValueError(f"{label} start must be greater than or equal to 0.")
+    if end is not None and end < 0:
+        raise ValueError(f"{label} end must be greater than or equal to 0.")
+    if start is not None and end is not None and end <= start:
+        raise ValueError(f"{label} end must be greater than the start time.")
+    return start, end
+
+
+def _parse_optional_seconds(
+    raw_text: str,
+    *,
+    field_name: str,
+    default: Optional[float],
+) -> Optional[float]:
+    text = str(raw_text or "").strip()
+    if not text:
+        return default
+    try:
+        return float(text)
+    except ValueError as exc:
+        raise ValueError(f"{field_name} must be a valid number of seconds.") from exc

ddalab_app/app/core/snapshot_payload.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from pathlib import Path
+from typing import Optional
+
+
+def relink_snapshot_payload(
+    payload: dict,
+    *,
+    old_path: str,
+    new_path: str,
+) -> dict:
+    rewritten = deepcopy(payload)
+    rewritten["activeFilePath"] = _replace_exact_path(
+        rewritten.get("activeFilePath"),
+        old_path,
+        new_path,
+    )
+    rewritten["openFiles"] = _replace_path_list(
+        rewritten.get("openFiles"),
+        old_path,
+        new_path,
+    )
+    rewritten["pinnedFiles"] = _replace_path_list(
+        rewritten.get("pinnedFiles"),
+        old_path,
+        new_path,
+    )
+    annotations = rewritten.get("annotationsByFile")
+    if isinstance(annotations, dict):
+        remapped: dict[str, object] = {}
+        for key, value in annotations.items():
+            remapped[new_path if key == old_path else str(key)] = value
+        rewritten["annotationsByFile"] = remapped
+    _rewrite_result_path(rewritten.get("ddaResult"), old_path, new_path)
+    _rewrite_result_path(rewritten.get("icaResult"), old_path, new_path)
+    return rewritten
+
+
+def first_missing_snapshot_source(payload: dict) -> Optional[str]:
+    active_file = payload.get("activeFilePath")
+    return active_file if isinstance(active_file, str) and active_file else None
+
+
+def missing_snapshot_source_name(payload: dict, missing_path: str) -> str:
+    active_file = payload.get("activeFilePath")
+    if isinstance(active_file, str) and active_file:
+        return Path(active_file).name
+    if missing_path:
+        return Path(missing_path).name
+    dda_result = payload.get("ddaResult")
+    if isinstance(dda_result, dict):
+        for key in ("fileName", "file_name"):
+            value = dda_result.get(key)
+            if isinstance(value, str) and value:
+                return value
+    return "snapshot dataset"
+
+
+def _replace_exact_path(value: object, old_path: str, new_path: str) -> object:
+    if isinstance(value, str) and value == old_path:
+        return new_path
+    return value
+
+
+def _replace_path_list(value: object, old_path: str, new_path: str) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    rewritten: list[str] = []
+    for item in value:
+        if not isinstance(item, str) or not item:
+            continue
+        rewritten.append(new_path if item == old_path else item)
+    return rewritten
+
+
+def _rewrite_result_path(payload: object, old_path: str, new_path: str) -> None:
+    if not isinstance(payload, dict):
+        return
+    for key in ("filePath", "file_path"):
+        value = payload.get(key)
+        if isinstance(value, str) and value == old_path:
+            payload[key] = new_path

ddalab_app/app/integrations/__init__.py

@@ -0,0 +1 @@
+"""External integration and export actions."""