From 2417493898b684be0100e554cdc07b0d2630754e Mon Sep 17 00:00:00 2001 From: Javier Garcia Ordonez Date: Fri, 28 Aug 2026 11:17:32 +0200 Subject: [PATCH] =?UTF-8?q?feat(engine):=20bump=20itis-dakota=201.5.11->6.?= =?UTF-8?q?24.7=20(Dakota=206.20->6.24)=20=E2=80=94=20T16mo=20rung=202?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Rung 2 of the engine modernization: move off the 1.5.x line (Dakota 6.20) to itis-dakota==6.24.7 (Dakota 6.24). 6.24.7 is the latest 6.24.x still shipping cp311 wheels, so itis-sumo keeps its Python 3.11 primary (parity with mmux/vite); 6.24.8+ dropped cp311 and would force a 3.12 migration of both repos (deferred). The 6.23+ `Interface::interface_cache()` regression (SPEC §R5) is still present in 6.24.7: `dakota.environment.study()`'s ctor throws `map::at` for itis-sumo's pure data-fit surrogate confs (no interface block), which broke all 45 real-Dakota surrogate tests. Shimmed in itis-sumo rather than waiting on the upstream get-or-create fix: `add_r5_interface_cache_workaround()` (appended to every conf via `start_dakota_file()`) declares an unused `single` model wired to a no-op `fork` interface (`analysis_drivers='true'`) and points each surrogate model at it via `truth_model_pointer='R5_WA_MODEL'`, forcing the Interface to be constructed (populating the cache) without ever executing it. 318-test suite green. Bumps itis-sumo version 0.1.0a3 -> 0.1.0a4. See SPEC §B B16mo, T16mo. --- SPEC.md | 9 +++--- pyproject.toml | 17 +++++++---- .../config/funs_create_dakota_conf.py | 29 +++++++++++++++++- uv.lock | 30 ++++++++++++------- 4 files changed, 63 insertions(+), 22 deletions(-) diff --git a/SPEC.md b/SPEC.md index 6750d50..a84fced 100644 --- a/SPEC.md +++ b/SPEC.md @@ -3,7 +3,7 @@ Caveman-encoded (drop articles/filler; `→` becomes, `!` must, `?` may/uncertain, `⊥` never). Standalone surrogate-modeling library aggregating prior MetaModeling trials. ## LINKS -- engine ! PyPI wheel `itis-dakota==1.5.11` (Dakota 6.20, T16mo rung 1 ✓, parity w/ mmux/vite). In-repo `itis-dakota/` = fork checkout, **REFERENCE-ONLY**: pkg consumes pre-built wheels, ⊥ builds fork (6.24 checkout kept for T16mo ladder) +- engine ! PyPI wheel `itis-dakota==6.24.7` (Dakota 6.24, T16mo rung 2 ✓ — latest 6.24.x still shipping cp311 wheels, so Python 3.11 parity w/ mmux/vite is retained; 6.24.8+ dropped cp311). In-repo `itis-dakota/` = fork checkout, **REFERENCE-ONLY**: pkg consumes pre-built wheels, ⊥ builds fork (6.24 checkout kept for T16mo ladder). The 6.23+ `interface_cache` regression (R5) is present upstream in 6.24.7 and is shimmed in itis-sumo (config/funs_create_dakota_conf.py::add_r5_interface_cache_workaround, `truth_model_pointer='R5_WA_MODEL'`), not waiting on the upstream get-or-create fix - feeding repos (per-branch/commit inventory + more-to-port → `PORTING.md`): - `../mmux_vite` (GiulianaRenc/mmux_vite): v1 port source = branch `jgo/sobol-indices`@`22685f7` → `flaskapi/src/mmux_flaskapi/{dakota,data_preprocessor}/`; E1 inspiration = branch `jgo/sumo-model-export-import`@`d5150b9` → re-implemented in-repo on `feat/sumo-model-export-import` (T12ze-T14qa ✓) - `../itis_dakota_projects` (ITISFoundation/itis-a-dakota-project) + `../itis_dakota_projects_clean` (ITISFoundation/itis_dakota_projects): recycled `validate_dakota_installation`/`get_dakota_version` + `validate` CLI @@ -32,7 +32,7 @@ Consumer contract (grill 2026-08-18): itis-sumo owns ALL surrogate machinery end - v1 config ! NIDR string composers (proven); JSON/pydantic seam later (DAKOTA-STUBS POC, Dakota 6.24 experimental) - port ! near-verbatim from mmux_flaskapi `dakota/`+`data_preprocessor/`; re-root `mmux_flaskapi.`→`itis_sumo.`; prune known-dead (`process_json_file`, `add_interface_s4l`, `create_function_sampling_conffile`, `create_moga_iterative_optimization_conffile`); de-web `JobVariableSelection`/`required_completed_jobs` (moved from blueprints into pkg) — SUPERSEDED in part by the tabular-only boundary below: `required_completed_jobs`' Dakota rule stays, the job-shaped models go back to the consumer (T24cm) - recycle itis_dakota_projects: `validate_dakota_installation()`, `get_dakota_version()`, `validate` CLI, config sanity-guard; ⊥ subprocess `DakotaProject`/factory/generator/parser/activity-logger -- deps ! itis-dakota==1.5.11 (Dakota 6.20, T16mo rung 1 ✓ — packaging-only bump, same engine as mmux/vite parity; stay until T16mo rung 2 resolves the 6.23+ `interface_cache` regression — R5), numpy, pandas, scipy; scikit-learn ⊥ KFold only +- deps ! itis-dakota==6.24.7 (Dakota 6.24, T16mo rung 2 ✓ — engine modernized 6.20→6.24; the 6.23+ `interface_cache` regression R5 is present upstream but shimmed in itis-sumo, see R5), numpy, pandas, scipy; scikit-learn ⊥ KFold only - py.typed; `src/` layout; docs MkDocs + headless notebook; tests standalone ⊥ flask/osparc - versioning single-source in `[project].version`; uv/uv_build + pip-compile pins; Conventional Commits - release channel policy: feature branches → `.devN` (manual alpha/dev prereleases); `develop` → `aN`; `main` → `bN` until `1.0.0` graduation; version bump ! enforced by a PR-time CI check (target-branch suffix, PEP 440 order, ⊥ reuse/regression); ⊥ bot commit on `develop`/`main` themselves (both branch-protected, no bypass granted) — a bot commit on a PR's OWN head branch, pre-merge, is unaffected by that constraint and is how the `aN` counter gets auto-bumped (T43bv); merge-time job ! push `v` tag only (tags fall outside 'require PR' branch protection); `develop` may later rename `staging` @@ -41,7 +41,7 @@ Consumer contract (grill 2026-08-18): itis-sumo owns ALL surrogate machinery end - TestPyPI publish token ! local `.env` (gitignored) `TESTPYPI_TOKEN`; Make injects `-t TESTPYPI_TOKEN`; ⊥ committed, ⊥ required as a pre-exported shell var - feature-branch TestPyPI local path ! `make publish-testpypi-dev` computes/writes next `.devN`, builds/checks/uploads via local `.env` token; ⊥ commit/tag/CI publication - E1: artifacts keyed server `sumo_model_id` (uuid); metadata sidecar `{id}.metadata.json`; ⊥ user-supplied path/prefix keys (traversal) -- py ! 3.11 primary (match mmux/vite); 3.10-3.13 all supported since T16mo rung 1 (1.5.11 ships cp313); rung 2 (6.24) still pending R5's upstream fix +- py ! 3.11 primary (match mmux/vite); 3.10-3.13 all supported; rung 2 took 6.24.7 (latest 6.24.x still shipping cp311 wheels) to retain 3.11 parity — 6.24.8+ dropped cp311 and would force a Python 3.12 migration (deferred; see T16mo) - cross-repo call surface ! narrow, versioned, "deep" entrypoints — one stitched public function per feature (e.g. `analyze_dataset()`), ⊥ flaskapi orchestrating several itis-sumo internals itself; version-pinning itis-sumo is fine (same pattern as the itis-dakota engine pin, T16mo) — the coupling risk is a *wide* call surface, not the pin - data in ! plain tabular (`pd.DataFrame` or an itis-sumo dataclass trivially convertible to one); ⊥ `FunctionJob`/oSPARC job concepts anywhere in itis_sumo. Ownership split: consumer converts jobs→table AND filters un-completed samples (warning); itis-sumo rejects insufficient/invalid data (raises; consumer catches + surfaces). Dakota sufficiency rule `max(5, n_variables + 1)` stays in itis-sumo - preprocessing ! auto-defaulted (novice/normal users pass nothing); advanced override allowed but expressed in DOMAIN vocabulary only (`scale`, `direction`); ⊥ transform vocabulary in any public signature (`sign_switch`, `normalization="zscore"`, `mapped_name`, `_hat`/`_std_hat`). Effective config → INSPECTABLE in results, ⊥ SETTABLE in transform terms. MOGA `direction` defaults `"minimize"` (optimization-field convention) @@ -135,7 +135,7 @@ T12ze|✓|E1: `core/sumo_model_store.py` (models dir single env-overridable sour T13uv|✓|E1: capture verbatim conf block for sidecar (close branch placeholder gap)|V10 T14qa|✓|E1: empirical export→import round-trip test (real, unmocked Dakota run — `tests/test_sumo_model_store.py`); resolves R2 `?`|R2,V11 T15mn|~|wire mmux/vite flaskapi to `itis_sumo.api` (export/import + all workflows): branch `feat/consume-itis-sumo-api` (worktree, pushed to `origin`, no PR yet) already replaces flaskapi's in-tree `dakota/`+`data_preprocessor/` w/ `itis_sumo.api` across all 7 workflows + drops the direct `itis-dakota` dep from flaskapi; pinned to itis-sumo `0.1.0.dev2` (TestPyPI); flaskapi suite verified 522 passed/3 skipped 2026-08-19 — remaining: open the PR, retarget the pin at a tagged `aN`/`bN` release instead of a `.devN` build (see parity note added to `../mmux_vite/flaskapi/SPEC.md` §C)|§I,R1-R4,T40qz -T16mo|~|stepwise engine modernization: rung 1 `1.5.9→1.5.11` ✓ (packaging-only bump, same 6.20 engine, behavior-identical — forced early by B14zt: 1.5.9 vanished from PyPI; 318-test local suite green, cp313 confirmed installable); rung 2 `1.5.11→6.24.x` co-shipped w/ JSON input seam (R5 regression fixed upstream first, re-align py 3.13, re-run full smoke) still pending|R4,R5 +T16mo|✓|stepwise engine modernization: rung 1 `1.5.9→1.5.11` ✓ (Dakota 6.20); rung 2 `1.5.11→6.24.7` ✓ (Dakota 6.24 engine bump). Took 6.24.7 — the latest 6.24.x still shipping cp311 wheels — to keep Python 3.11 parity with mmux/vite; 6.24.8+ dropped cp311 (would force a 3.12 migration, deferred). The 6.23+ `interface_cache` regression (R5) was NOT fixed upstream in 6.24.7, so itis-sumo shims it via `add_r5_interface_cache_workaround()` + `truth_model_pointer='R5_WA_MODEL'` in config/funs_create_dakota_conf.py: a no-op `fork` interface (`analysis_drivers='true'`) on an otherwise-unused `single` model, so the `study()` ctor's cache lookup succeeds; the interface is never executed. JSON input seam (R4) deferred per scope. 318-test suite green|R4,R5 T17bq|✓|`add_surrogate_model` (`config/funs_create_dakota_conf.py`) ! replaced filename-substring sniffing w/ explicit `has_eval_id_column` param (infer-or-override idiom); all 5 `create_sumo_*_conffile` call sites updated (landed via `feat/vv-port-tests-and-docs`, `a6d694e`, ahead of this merge)|V15,B2 T17bc|✓|E1: persist real training data on export for reference (`{id}.processed_training.dat` sidecar copy, user preference over the leaner archive-only design); `stage_model_for_import` stages it back, falling back to a synthesized header-only placeholder + loud warning log only when that stored copy is missing (legacy model / deleted out-of-band) — fallback verified safe vs Dakota source + fake-points empirical tests (header reorder, wrong/missing descriptors, 0/1/2-row placeholders)|R8,R9,V10,V11 T18ry|.|design+implement `analyze_dataset(df, input_cols, output_cols, alpha=0.05, include_detail=False) -> DatasetDiagnostics` narrow entrypoint (scale/distribution auto-selection + outlier surfacing, plain dataclasses, JSON-serializable via `dataclasses.asdict()`) as the sole flaskapi-facing dataset-diagnostics API, replacing any per-function flaskapi orchestration; BLOCKED — building blocks `select_variable_scale`/`auto_select_distributions` (+ a new raw-value outlier detector, reusing `_tukey_outlier_mask`'s IQR technique) currently exist only on confidential incubator branch `feat/nih-in-silico-example`, not `develop` — needs individual promotion first, same promotion rule as T15mn/E1|§C,V16qf,I @@ -187,3 +187,4 @@ B12mn|2026-08-19|`pyproject.toml` `requires-python` had drifted to `>=3.10,<3.14 B13qf|2026-08-19|3 latent Python-3.10 incompatibilities (`datetime.UTC`, `typing.Self`, bare `import tomllib` — all stdlib/typing 3.11+ additions) shipped undetected because the pre-`ci/matrix-and-coverage` CI ran a single Python version; surfaced only once the 3.10-3.13 test matrix actually ran each version for the first time|`datetime.timezone.utc` / `sys.version_info`-gated `typing_extensions.Self` fallback / try-`tomllib`-except-`tomli` fallback + conditional deps; preventive: V41hp — `ty check` resolves these against `requires-python`'s floor in one static run, cheaper than a runtime matrix for this bug class B14zt|2026-08-27|`itis-dakota==1.5.9` was deleted from PyPI upstream (release list jumps `1.5.1`→`1.5.11`→`6.23.0`+, no `1.5.9`; that version's PyPI JSON endpoint 404s) — invisible because `uv.lock` still installs from its cached wheel URLs/hashes, but T43bv's alpha-bump commit changes `pyproject.toml`'s `[project]` table on every qualifying PR, which invalidates the lock and forces a live re-resolve; that re-resolve then fails outright since the pinned version no longer exists in the index (reproduced locally: identical repo, only `version` differs, `uv@latest sync` succeeds unchanged / fails re-resolved)|bumped engine pin to `itis-dakota==1.5.11` (T16mo rung 1, already earmarked in a pyproject.toml comment — packaging-only, same Dakota 6.20 engine, adds cp313 wheels); widened `requires-python` to `<3.14`; regenerated `uv.lock`; 318-test local suite + `ty`/`ruff` green, cp313 install confirmed; V43zt B15tg|2026-08-27|the `v0.1.0a2` tag (created by auto-tag.yml on the develop merge) exists, but no TestPyPI publish followed — auto-tag's trailing `gh workflow run publish.yml` did not fire. Root cause: the `tag-merged-version` step invoked `gh` from an inline Python script that read `GITHUB_TOKEN` out of the step environment, but the step's `env:` block only exported `GH_REF_NAME`, so `gh` got no usable token and the dispatch silently did nothing|add `GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}` to the `tag-merged-version` step's `env:` block so the inline `gh` call inherits a valid token; one-off `gh workflow run publish.yml --ref develop --field tag=v0.1.0a2 --field registry=testpypi` published a2 manually to recover the missed alpha; V29yn +B16mo|2026-08-28|T16mo rung 2 bumped the engine `itis-dakota==1.5.11` (Dakota 6.20) → `==6.24.7` (Dakota 6.24). 6.24.7 still carries the 6.23+ `Interface::interface_cache()` regression (R5): `dakota.environment.study()`'s ctor unconditionally calls `interface_cache(problem_db)` and throws `IndexError: map::at` ("called with nonexistent study!") for itis-sumo's pure data-fit surrogate confs, which construct no Interface (only `import_build_points_file`, no `interface` block) — the cache static map is never populated. All 45 real-Dakota surrogate tests failed on it (training, cross-validation, UQ propagation, MOGA, import/export, evaluation). Upstream fix (get-or-create `operator[]`) is still pending|shim in itis-sumo, not waiting on upstream: `config/funs_create_dakota_conf.py::add_r5_interface_cache_workaround()` (appended to every conf via `start_dakota_file()`) declares an unused `single` model `R5_WA_MODEL` wired to a no-op `fork` interface (`analysis_drivers='true'`) and points each surrogate `model` at it via `truth_model_pointer='R5_WA_MODEL'`, forcing the Interface to be constructed (populating the cache) during study setup; the dummy model is never referenced by any method/iterator so the interface is never executed. 318-test suite green on 6.24.7. Took 6.24.7 (not 6.24.9) because 6.24.8+ dropped cp311 wheels, which would have forced a Python 3.12 migration of both repos; R5 diff --git a/pyproject.toml b/pyproject.toml index 08aad38..0135b4f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "uv_build" [project] name = "itis-sumo" -version = "0.1.0a3" +version = "0.1.0a4" description = "Surrogate Modeling functionality for IT'IS Foundation / ZMT Modeling Intelligence suite: build, evaluate, cross-validate surrogates + UQ + sampling, headless or embedded" readme = "README.md" # T16mo rung 1 (1.5.9->1.5.11): 1.5.11 ships cp313 wheels, so the <3.13 @@ -23,11 +23,16 @@ classifiers = [ "Topic :: Scientific/Engineering", ] dependencies = [ - # T16mo rung 1: itis-dakota==1.5.11 (still Dakota 6.20, packaging-only - # bump -- behavior-identical to 1.5.9). Stay on 6.20 until the 6.23+ - # `Interface::interface_cache()` regression is resolved (SPEC §T T16mo - # rung 2). 1.5.9 itself was removed from PyPI (SPEC §B). - "itis-dakota==1.5.11", + # T16mo rung 2: itis-dakota==6.24.7 (Dakota 6.24). The 1.5.x line wrapped + # Dakota 6.20; the package renumbered to track Dakota's version. Bumps the + # engine a full minor (6.20 -> 6.24). 6.24.7 is the latest 6.24.x that still + # ships cp311 wheels, so itis-sumo keeps its Python 3.11 primary (parity + # with mmux/vite); 6.24.8+ dropped cp311. The 6.23+ `interface_cache` regression + # (SPEC §R5) on pure data-fit surrogate confs is shimmed in itis-sumo via + # `add_r5_interface_cache_workaround()` in config/funs_create_dakota_conf.py + # (no-op fork interface so the ctor's cache lookup succeeds), rather than + # waiting on the upstream get-or-create fix. + "itis-dakota==6.24.7", "numpy>=2.0,<3.0", "pandas>=2.2,<3.0", "pydantic>=2.0,<3.0", diff --git a/src/itis_sumo/config/funs_create_dakota_conf.py b/src/itis_sumo/config/funs_create_dakota_conf.py index fb8ce3f..95f7cb3 100644 --- a/src/itis_sumo/config/funs_create_dakota_conf.py +++ b/src/itis_sumo/config/funs_create_dakota_conf.py @@ -7,6 +7,32 @@ _logger = logging.getLogger(__name__) +def add_r5_interface_cache_workaround() -> str: + """T16mo rung 2 / SPEC §R5: itis-dakota 6.24's `study()` ctor unconditionally + calls `Interface::interface_cache(problem_db)` and throws `map::at` + ("called with nonexistent study!") when the study constructed no Interface -- + which is exactly the case for itis-sumo's pure data-fit surrogate confs + (`import_build_points_file`, no interface). The cache is only populated when an + Interface is constructed. This appends an otherwise-unused `single` model backed + by a no-op `fork` interface so the cache gets an entry and the ctor succeeds. The + dummy model is never referenced by any method/iterator, so the interface is never + executed. Upstream's own fix is a get-or-create (`operator[]`) in `interface_cache` + (pending in itis-dakota); this is the itis-sumo-side shim until then. + """ + return """ + model + id_model = 'R5_WA_MODEL' + single + interface_pointer = 'R5_WA_INTERFACE' + variables_pointer = 'VARIABLES' + responses_pointer = 'RESPONSES' + interface + id_interface = 'R5_WA_INTERFACE' + fork + analysis_drivers = 'true' + """ + + def start_dakota_file( top_method_pointer: str | None = None, results_file_name: str | None = None, @@ -20,7 +46,7 @@ def start_dakota_file( tabular_data tabular_data_file = '{results_file_name}' {f"top_method_pointer = '{top_method_pointer}'" if top_method_pointer is not None else ""} - """ + """ + add_r5_interface_cache_workaround() def add_adaptive_sampling( @@ -130,6 +156,7 @@ def add_surrogate_model( conf = f""" model id_model '{id_model}' + truth_model_pointer = 'R5_WA_MODEL' surrogate global {surrogate_type} """ diff --git a/uv.lock b/uv.lock index b92a040..30b80a8 100644 --- a/uv.lock +++ b/uv.lock @@ -430,7 +430,7 @@ wheels = [ [[package]] name = "itis-dakota" -version = "1.5.11" +version = "6.24.7" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, @@ -438,19 +438,27 @@ dependencies = [ { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, ] wheels = [ - { url = "https://files.pythonhosted.org/packages/36/9b/c1414ccf484eb37e69f386a92b92897788ee005da0057c2cf560f64ebbd0/itis_dakota-1.5.11-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:28484557a96b9ee51b842052166200dc817cb46336afd5e104cdcc7e00a20bd4", size = 35189672, upload-time = "2025-06-30T09:44:42.989Z" }, - { url = "https://files.pythonhosted.org/packages/ef/a8/93add2546c41ff6a8df8e6e6b8fe933a86adfab8c16171bd44997b97200e/itis_dakota-1.5.11-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:51e71274beebcebb7c0b43d9a8f96b394d790ffab57b0b8465a4ef561c929c03", size = 37738386, upload-time = "2025-06-30T09:44:46.763Z" }, - { url = "https://files.pythonhosted.org/packages/3f/b2/47ff96944b8da46da9965e19ede1796a67c87c1c53f8633b066d4496e3bc/itis_dakota-1.5.11-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:a2d681907203c70de332ae6bd861e6cc547d3611547af6ad276f43f21c5ef88f", size = 35192830, upload-time = "2025-06-30T09:44:50.176Z" }, - { url = "https://files.pythonhosted.org/packages/f3/52/c1b51be316124e390a31d20b4c4eeadd5ccee43a9c9268d95a2daf0e1bb2/itis_dakota-1.5.11-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:9da371d788080902aefd0d9c3a65be0ecb83e5802ee800b4782cd490fec8cd01", size = 37741294, upload-time = "2025-06-30T09:44:53.722Z" }, - { url = "https://files.pythonhosted.org/packages/7f/8b/c5ed69331dbae789b45abd5103f10fbe56d2570beb1c2b578267c0e75d78/itis_dakota-1.5.11-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:79896f15e2eb7f6f0086d4d54ef0994a1eb9de200c7729c3c60a09feb8961c55", size = 35192972, upload-time = "2025-06-30T09:44:57.462Z" }, - { url = "https://files.pythonhosted.org/packages/46/ba/a64379564c843725d5e240cd43f7a2362f1ff340e1e24e30b5bedd57e1ec/itis_dakota-1.5.11-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:4922a767ca13cf9aec06e7cc4100876efed99a39897aa8ca2b728d2ca1434384", size = 37740118, upload-time = "2025-06-30T09:45:01.099Z" }, - { url = "https://files.pythonhosted.org/packages/66/3d/fa91c3697a2c4178f0d33b45e64f9ae6bae7bef1f989749c962ae22a92ab/itis_dakota-1.5.11-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:c1fdf6bcef5eabcc8fc756b1b0342d5f4152c40bd4eb4f383e83b7a0c5d79656", size = 35194105, upload-time = "2025-06-30T09:45:05.218Z" }, - { url = "https://files.pythonhosted.org/packages/90/25/22bb2b4459858a1e50ef51c0c10f279f36fc8b26d4d703b30e1e325f55e1/itis_dakota-1.5.11-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:3d70fee81c91a727ac935a5721b250e68103743755b960491b8fa2c5281fa428", size = 37743856, upload-time = "2025-06-30T09:45:08.974Z" }, + { url = "https://files.pythonhosted.org/packages/e2/0e/c185836210377777250818ffe9966c2ecdf3d674b70d7e77e8b81ae4c85a/itis_dakota-6.24.7-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:f244035d82753942ef844f6a3f47f54d89176f3a3720e65442e3bb5ee50c616f", size = 59159680, upload-time = "2026-08-11T21:06:03.056Z" }, + { url = "https://files.pythonhosted.org/packages/2d/53/7f71b83b148722945f9f9e59a01dbc02d9c1eebf0327f8b607dfed6be11e/itis_dakota-6.24.7-cp310-cp310-macosx_15_0_x86_64.whl", hash = "sha256:b14a5aca19032f8da50a88f9fd5581a00b1f7766d6fa62d033496247d4b3cb49", size = 65714024, upload-time = "2026-08-11T21:06:08.083Z" }, + { url = "https://files.pythonhosted.org/packages/7b/32/456f49c63955602f4f02c9bc73be812b66c155f54cc643044d9ddc397734/itis_dakota-6.24.7-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:04610d4849c132092f2aa813198eef6d1175ab84023deb25694517a5db47e2a2", size = 67314291, upload-time = "2026-08-11T21:06:13.451Z" }, + { url = "https://files.pythonhosted.org/packages/3f/b6/0f37e7c36d376ec636924003cd1bdfbf7ed06793a075884e2e3dc689aa6d/itis_dakota-6.24.7-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:fe666c942b2701850cfb5d7d659b04e09c72f8c63a1bcec7bb2635d36b44d99e", size = 71952924, upload-time = "2026-08-11T21:06:19.615Z" }, + { url = "https://files.pythonhosted.org/packages/f8/1b/0bf1d3c1f5e83946596995a6b9071e5cf9f11384786317043a26a1644174/itis_dakota-6.24.7-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:edbe7d6bc7c2ab422df730e770b8d3328ba6913775f5294a1141f133296e034a", size = 59166496, upload-time = "2026-08-11T21:06:25.365Z" }, + { url = "https://files.pythonhosted.org/packages/e2/49/824cf5f8f6911025402d1963dfad8fd5d1cd4e578dcb57780b6555f4aee3/itis_dakota-6.24.7-cp311-cp311-macosx_15_0_x86_64.whl", hash = "sha256:9a56e5e1cba6f1ba838c186f9c8dd502755cfe016433973f9bb8eb39c3b51988", size = 65737602, upload-time = "2026-08-11T21:06:31.247Z" }, + { url = "https://files.pythonhosted.org/packages/ca/b2/83b40adf939564968231935f59cd7b6fe74d6737a5d5b36147c76ccbc611/itis_dakota-6.24.7-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:323b21abc6b2c9a2efd2787951274cf671a50a462b6e7ff5042b60b855975ec6", size = 67518343, upload-time = "2026-08-11T21:06:36.753Z" }, + { url = "https://files.pythonhosted.org/packages/1c/c3/c7befac8127b9b899f43257717fd760e5d3d4411b7bbcabd3687c60fdeff/itis_dakota-6.24.7-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:e1f7f929c3ee99a9eb5a7612efe3229d299bc9cc25e53ad054095aa64ce927c9", size = 72183297, upload-time = "2026-08-11T21:18:56.92Z" }, + { url = "https://files.pythonhosted.org/packages/a8/3a/5bab9f6315f6936fc01c34d5b00ef428ee61d18c1279183139134fb6fc9a/itis_dakota-6.24.7-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:4a2a19c7c8c561c2bb9a8f37f3ac87bf1472f4452ecefe7d58bba09ea76e95c4", size = 59164513, upload-time = "2026-08-11T21:19:02.969Z" }, + { url = "https://files.pythonhosted.org/packages/68/19/6a10eae26c0a3eb28e71ee6a17bea899fd64a8cb4377444ab0feb32e9991/itis_dakota-6.24.7-cp312-cp312-macosx_15_0_x86_64.whl", hash = "sha256:f16358d5aec9451c4b2585890f3277d5dc07748d09cffdccdb705d764191a638", size = 65735630, upload-time = "2026-08-11T21:19:09.694Z" }, + { url = "https://files.pythonhosted.org/packages/29/e8/a76562b1f8854335d49ff6be7a9489f58b2f5d1b07cba9df23bb9efa47c0/itis_dakota-6.24.7-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:fc38f392faca5efd0a2c25d8495d801c2381b04d7b3dc58284197372b35cff39", size = 67781300, upload-time = "2026-08-11T21:19:17.422Z" }, + { url = "https://files.pythonhosted.org/packages/6b/76/d05abbdf9b1dd0629ef625de1da429c4affcbd2ba8d20e0e71084e869fb3/itis_dakota-6.24.7-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:3493cd374e2fefaf8b2ba691d6484cb6cb35e2a2b19b867c3384f9b6d928edbc", size = 72460282, upload-time = "2026-08-11T21:19:25.508Z" }, + { url = "https://files.pythonhosted.org/packages/c4/b3/f33ba12215935c95d5f3ab1836cefbfbea1bee195b17d520a76ec720ddbb/itis_dakota-6.24.7-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:0ebeccee782dc5d2e065c2d7932e2fb023d91a9c740ab4da23c4ddd25a95b2b8", size = 59163698, upload-time = "2026-08-11T21:19:32.846Z" }, + { url = "https://files.pythonhosted.org/packages/a1/e3/28d81977737dcfd026b75d0c94023e660c1342977b0a19d938bcedef29ec/itis_dakota-6.24.7-cp313-cp313-macosx_15_0_x86_64.whl", hash = "sha256:f14e621fca1626eef6e2a09ac3d8d567c397af68e96c5f19dbb59252c11b1b81", size = 65736139, upload-time = "2026-08-11T21:19:40.019Z" }, + { url = "https://files.pythonhosted.org/packages/91/2d/c423ccbfa24c36903392da6792033df5c29accac3065b08a7c61385cddce/itis_dakota-6.24.7-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:44a50b7b4a4bc3310d87403caf001775f9db2dd2ff8afc535d3595d583fd42cd", size = 67736226, upload-time = "2026-08-11T21:19:47.271Z" }, + { url = "https://files.pythonhosted.org/packages/6a/5a/dff08421fb84738a4b61060c5aa87250c1c1406299bb6e95533e1454b49b/itis_dakota-6.24.7-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:86dea299e34d5b03191dd6ced84b4a428f8441d67349213244be8e7b15ef3c7e", size = 72378040, upload-time = "2026-08-11T21:19:54.439Z" }, ] [[package]] name = "itis-sumo" -version = "0.1.0a2" +version = "0.1.0a4" source = { editable = "." } dependencies = [ { name = "itis-dakota" }, @@ -484,7 +492,7 @@ docs = [ [package.metadata] requires-dist = [ - { name = "itis-dakota", specifier = "==1.5.11" }, + { name = "itis-dakota", specifier = "==6.24.7" }, { name = "numpy", specifier = ">=2.0,<3.0" }, { name = "pandas", specifier = ">=2.2,<3.0" }, { name = "pydantic", specifier = ">=2.0,<3.0" },