scistackplotdb 0.1.31__tar.gz → 0.1.33__tar.gz

{scistackplotdb-0.1.31 → scistackplotdb-0.1.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: scistackplotdb
-Version: 0.1.31
+Version: 0.1.33
 Summary: scidb-backed plotting: load variables into long tables and plot them with scistackplot
 Author: SciStack Contributors
 License-Expression: MIT
@@ -17,8 +17,10 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: scistack-db>=0.1.0
-Requires-Dist: scistackplot>=0.1.0
+Requires-Dist: sciduckdb==0.1.33
+Requires-Dist: scistack-db==0.1.33
+Requires-Dist: scistacklog==0.1.33
+Requires-Dist: scistackplot==0.1.33
 Provides-Extra: dev
 Requires-Dist: matplotlib>=3.6; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0; extra == 'dev'

{scistackplotdb-0.1.31 → scistackplotdb-0.1.33}/pyproject.toml

@@ -1,14 +1,22 @@
 [build-system]
-requires = ["hatchling", "hatch-vcs"]
+requires = ["hatchling", "hatch-vcs", "hatch-dependency-coversion==0.0.1a4"]
 build-backend = "hatchling.build"
 
 [tool.hatch.version]
 source = "vcs"
 raw-options = { search_parent_directories = true, local_scheme = "no-local-version" }
 
+# Sibling SciStack packages are pinned to EXACTLY this build's version at build
+# time (lockstep releases), so [project] dependencies lists them unversioned. The
+# extra "dynamic" entry is what makes hatchling run the hook. Every sibling in
+# dependencies must be named here: CI's build job fails a wheel whose internal
+# dependency is not "==<its own version>".
+[tool.hatch.metadata.hooks.dependency-coversion]
+override-versions-of = ["scistackplot", "scistack-db", "sciduckdb", "scistacklog"]
+
 [project]
 name = "scistackplotdb"
-dynamic = ["version"]
+dynamic = ["version", "dependency-coversioning"]
 description = "scidb-backed plotting: load variables into long tables and plot them with scistackplot"
 readme = "README.md"
 license = "MIT"
@@ -37,8 +45,10 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "scistackplot>=0.1.0",
-    "scistack-db>=0.1.0",
+    "scistackplot",
+    "scistack-db",
+    "sciduckdb",
+    "scistacklog",
 ]
 
 [project.optional-dependencies]

{scistackplotdb-0.1.31 → scistackplotdb-0.1.33}/src/scistackplotdb/_versioned.py

@@ -352,3 +352,41 @@ class VersionedStore:
             )
             return {}
         return envelope
+
+    # ---- copying a whole store (project bundles) ------------------------
+
+    def _all_columns(self) -> list[str]:
+        scope = [self.scope_column] if self.scope_column else []
+        return [self.id_column, *scope, "name", "version", "saved_at", "hidden", "envelope_json"]
+
+    def dump_rows(self, db) -> list[dict]:
+        """Every row, every version, hidden ones too, as plain dicts: what a
+        project bundle carries (``scistackplotdb.bundle_section``). Nothing
+        is filtered -- a copy keeps the history the original kept."""
+        if not self.table_exists(db):
+            return []
+        cols = self._all_columns()
+        rows = db._duck._fetchall(
+            f"SELECT {', '.join(cols)} FROM {self.table} ORDER BY {self.id_column}, version"
+        )
+        Log.info("[%s] dump_rows: %d row(s)", self.tag, len(rows), layer=LAYER)
+        return [dict(zip(cols, row)) for row in rows]
+
+    def load_rows(self, db, rows: list[dict]) -> int:
+        """Insert *rows* (from :meth:`dump_rows`) verbatim, ids and versions
+        kept; a row already present is left as it is. Returns rows inserted."""
+        if not rows:
+            return 0
+        self.ensure_table(db)
+        cols = self._all_columns()
+        before = db._duck._fetchone(f"SELECT count(*) FROM {self.table}")[0]
+        for row in rows:
+            db._duck._execute(
+                f"INSERT INTO {self.table} ({', '.join(cols)}) "
+                f"VALUES ({', '.join('?' for _ in cols)}) ON CONFLICT DO NOTHING",
+                [row.get(c) for c in cols],
+            )
+        after = db._duck._fetchone(f"SELECT count(*) FROM {self.table}")[0]
+        Log.info("[%s] load_rows: %d of %d row(s) inserted", self.tag, after - before,
+                 len(rows), layer=LAYER)
+        return after - before

scistackplotdb-0.1.33/src/scistackplotdb/bundle_section.py

@@ -0,0 +1,59 @@
+"""
+The ``plots`` section of a project bundle (``scidb.bundle``): saved plots and
+plot presets, copied row for row.
+
+Both stores key nothing by canvas ids or database record ids -- a saved plot
+is named per VARIABLE, a preset per project -- so a verbatim copy into the
+new project is the whole story: ids, versions and hidden rows kept, exactly
+as the exporting project had them (``VersionedStore.dump_rows`` /
+``load_rows``, the one owner of the table's columns).
+"""
+
+from __future__ import annotations
+
+import json
+
+from scistacklog import Log
+
+from . import presets, saved
+
+LAYER = "scistackplotdb"
+
+_STORES = {"saved_plots.json": saved.STORE, "presets.json": presets.STORE}
+
+
+class PlotsSection:
+    name = "plots"
+
+    def export(self, ctx) -> "dict[str, bytes]":
+        files: dict[str, bytes] = {}
+        for filename, store in _STORES.items():
+            rows = store.dump_rows(ctx.db)
+            if rows:
+                files[filename] = json.dumps(rows, indent=2, default=str).encode("utf-8")
+        Log.info("[bundle_section] plots export: %s", sorted(files), layer=LAYER)
+        return files
+
+    def import_(self, ctx, files: "dict[str, bytes]") -> dict:
+        report = {}
+        key_map = getattr(ctx, "key_map", None)
+        for filename, store in _STORES.items():
+            if filename in files:
+                rows = json.loads(files[filename].decode("utf-8"))
+                if key_map is not None and not key_map.is_identity:
+                    rows = [_remap_row(row, store, key_map, ctx.map_report) for row in rows]
+                report[store.table] = store.load_rows(ctx.db, rows)
+        Log.info("[bundle_section] plots import: %s", report, layer=LAYER)
+        return report
+
+
+def _remap_row(row: dict, store, key_map, map_report) -> dict:
+    """A saved plot or preset carried into another schema (portability Stage
+    6). A spec names factors in many fields (roles, groups, facets, colours,
+    filters, difference bars, ...), so every string EQUAL to an exporter key
+    is renamed (``KeyMap.exact_strings``) and the item is flagged for review
+    -- a factor that merely equals a key name cannot be told apart."""
+    envelope = json.loads(row["envelope_json"])
+    where = f"{store.noun} {row.get('name')!r}"
+    mapped = key_map.exact_strings(envelope, where, map_report)
+    return {**row, "envelope_json": json.dumps(mapped)}