pypsbuilder 2.6.6__tar.gz → 2.6.8__tar.gz

{pypsbuilder-2.6.6 → pypsbuilder-2.6.8}/.github/workflows/testing.yml

@@ -9,9 +9,11 @@ on:
 jobs:
   build:
     name: Package testing
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
         python-version: ["3.12", "3.13", "3.14"]
 
     env:
@@ -28,6 +30,7 @@ jobs:
           enable-cache: true
 
       - name: Install Qt runtime dependencies
+        if: runner.os == 'Linux'
         run: |
           sudo apt-get update
           sudo apt-get install -y libegl1 libxkbcommon0

{pypsbuilder-2.6.6 → pypsbuilder-2.6.8}/.readthedocs.yaml

@@ -22,6 +22,7 @@ build:
 python:
   install:
     - method: uv
+      command: sync
       path: .
       extras:
         - docs

{pypsbuilder-2.6.6 → pypsbuilder-2.6.8}/CHANGELOG.md

@@ -1,6 +1,23 @@
 # Changelog
 All notable pypsbuilder changes.
 
+## [2.6.8] - 2026-09-05
+### Added
+ - `Export JSON` menu item added to ptbuilder/txbuilder/pxbuilder File menu, exporting invariant points and univariant lines in a schema readable back in by `Import from JSON`
+### Fixed
+ - TC35API rejects `omit` scriptfile script as unrecognised (discontinued in THERMOCALC 3.51); use `with`/`inexcess` instead
+ - TC35API bombed-run detection matches THERMOCALC 3.51's actual `-- run bombed` output
+ - About, Modes and Full TC output dialogs no longer get hidden behind the main builder window; About dialog now also shows the builder's icon
+ - `Import from JSON` no longer requires an empty project; existing invariant points/univariant lines are left untouched and only genuinely new entries are calculated. It seeds THERMOCALC ptguesses from the nearest already-calculated invariant point before each calculation
+ - `tcinit`'s bundled TC 3.51 starting-guess template used inconsistent solution-model names (`L`, `pl`, `ksp` instead of `liq`, `pl4tr`, `k4tr`) for the same phases it names correctly elsewhere in the template
+### Changed
+ - CI test matrix now runs on Linux, Windows and macOS (in addition to the existing Python version matrix)
+
+## [2.6.7] - 2026-08-29
+### Added
+ - `tcinit` now prompts for the P-T range (`[pmin, pmax, tmin, tmax]`), used to set the generated scriptfile's `diagramPT`/`calcP`/`calcT` lines
+ - `tcinit` creates the destination directory automatically when it doesn't exist yet but its parent does
+
 ## [2.6.6] - 2026-08-29
 ### Fixed
  - project extra jupyter renamed to lab

{pypsbuilder-2.6.6 → pypsbuilder-2.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pypsbuilder
-Version: 2.6.6
+Version: 2.6.8
 Summary: THERMOCALC front-end for constructing and analyzing PT pseudosections
 Project-URL: Homepage, https://github.com/ondrolexa/pypsbuilder
 Project-URL: Documentation, https://pypsbuilder.readthedocs.io

{pypsbuilder-2.6.6 → pypsbuilder-2.6.8}/docs/psbuilders-tutorial.rst

@@ -65,18 +65,23 @@ Using tcinit to setup working directory
 ---------------------------------------
 
 For TC3.5 you can use the ``tcinit`` command to initialize a working
-directory. Run it in an empty directory and answer the prompts::
+directory. Run it and answer the prompts::
 
 		$ tcinit
 
-It downloads THERMOCALC 3.51 for your platform (Linux, Windows or macOS) and
-lets you choose one of four bundled datasets/a-x files: ``metapelite``,
-``metabasite``, ``igg25`` (igneous, White et al. 2025 update) or ``igw24``
-(igneous, Weller et al. 2024). The chosen dataset, a-x file, starting
-guesses and preferences file are written into the project directory,
-already tagged with the ``%{PSBGUESS-...}``, ``%{PSBCALC-...}`` and
-``%{PSBBULK-...}`` blocks described above, so the resulting scriptfile works
-with ``ptbuilder``/``txbuilder``/``pxbuilder`` out of the box.
+You will be asked for a project directory (defaults to the current
+directory; if it doesn't exist yet but its parent does, it is created for
+you automatically), a project name (max 8 characters), the P-T range to use
+(``[pmin, pmax, tmin, tmax]``, defaulting to ``[1.9, 10.1, 345, 805]`` and
+written into the scriptfile's ``diagramPT``/``calcP``/``calcT`` lines), and
+one of four bundled datasets/a-x files: ``metapelite``, ``metabasite``,
+``igg25`` (igneous, White et al. 2025 update) or ``igw24`` (igneous, Weller
+et al. 2024). It then downloads THERMOCALC 3.51 for your platform (Linux,
+Windows or macOS). The chosen dataset, a-x file, starting guesses and
+preferences file are written into the project directory, already tagged
+with the ``%{PSBGUESS-...}``, ``%{PSBCALC-...}`` and ``%{PSBBULK-...}``
+blocks described above, so the resulting scriptfile works with
+``ptbuilder``/``txbuilder``/``pxbuilder`` out of the box.
 
 
 New P-T pseudosection project
@@ -245,6 +250,35 @@ When you have already calculated invariant points and lines and you want to use
 them in separate project, create new project, set axes limits properly and
 use `File>Import > Import into range` to read it.
 
+Import and export JSON
+-----------------------
+
+Besides the ``.ptb``/``.txb``/``.pxb`` project files, invariant points and
+univariant lines can be exchanged as plain JSON, e.g. to share a
+pseudosection's topology without the project file, or to seed a new project
+from results calculated elsewhere.
+
+``File>Export>Export JSON...`` writes the current project's invariant points
+and univariant lines to a JSON file with top-level keys ``kind`` (``"PT"``,
+``"TX"`` or ``"PX"``), ``P``/``T`` (the diagram's fixed P or T value for
+T-X/P-X sections, otherwise its ``[min, max]`` range), and ``inv``/``uni``
+lists. Each entry in ``inv``/``uni`` carries ``P``/``T``/``X`` (a
+``[min, max]`` range, or ``null`` for the axis unused by this builder's
+``kind``), ``phases`` and ``out`` (the zero-mode phase(s): two for an
+invariant point, one for a univariant line).
+
+``File>Import>Import from JSON...`` reads such a file back and calculates any
+invariant point or univariant line not already present in the project
+(existing ones are left untouched and reported as duplicates). Its P/T range
+must fit inside the project's own diagram window, and phases referenced in
+the file that aren't defined in this project prompt for a replacement name
+(or are resolved from a ``phase_map`` when calling ``import_from_json()``
+from a script). Each calculation is seeded from the nearest already
+calculated invariant point, invariant points that fail on the first pass are
+retried once more points are available as seeds, and univariant lines are
+stepped along whichever axis they run along more, at a resolution capped
+relative to the full diagram range.
+
 T-X and P-X pseudosections
 --------------------------
 

{pypsbuilder-2.6.6 → pypsbuilder-2.6.8}/examples/avgpelite/tc-avgpelite.txt

@@ -1,6 +1,6 @@
 % ==================================================================
 % Scriptfile for pypsbuilder calculation
-% 
+%
 % Use "%" for commenting (nothing is read between % and the line ending).
 % No lines are read after the "*" character.
 % DO NOT REMOVE pypsbuilder TAGS !!!
@@ -16,7 +16,6 @@ autoexit
 
 inexcess q H2O
 %tozero H2O
-omit sp0 sp1 Ni NiO opx sp ta plc abh ilmm hemm ilm0 ksp0 mt0 mt1 heme
 
 % =======================
 % which conditions
@@ -61,7 +60,7 @@ samecoding plc pl      % rename Cbar1 plagioclase as 'pl'
 
 %{PSBGUESS-BEGIN}
 % ----------------------------------------------------------
-% at P = 5.5, T = 500, for: g pl mu bi chl ab ru q H2O 
+% at P = 5.5, T = 500, for: g pl mu bi chl ab ru q H2O
 % ----------------------------------------------------------
 ptguess 5.539 500.35
 % ----------------------------------------------------------
@@ -98,7 +97,7 @@ xyzguess Q4(chl)      0.0941449  range -1.000 1.000
 
 % --------------------------------------------------------
 % Starting guesses in MnNCKFMASHTO (over-ridden by any above)
-% for g liq pl ksp ep ma mu pa bi opx sa cd st chl ctd sp mt ilmm hemm ilm hem mt1  
+% for g liq pl ksp ep ma mu pa bi opx sa cd st chl ctd sp mt ilmm hemm ilm hem mt1
 % --------------------------------------------------------
 
 xyzguess x(g)          0.824169
@@ -121,9 +120,9 @@ xyzguess na(ksp)       0.227897
 xyzguess ca(ksp)      0.0114380
 
 xyzguess f(ep)         0.379418
-xyzguess Q(ep)         0.346850  range  0.000 0.500 
+xyzguess Q(ep)         0.346850  range  0.000 0.500
 
-xyzguess x(ma)         0.6  
+xyzguess x(ma)         0.6
 xyzguess y(ma)         0.96
 xyzguess f(ma)         0.001
 xyzguess n(ma)         0.05
@@ -133,7 +132,7 @@ xyzguess x(mu)         0.501982
 xyzguess y(mu)         0.839614
 xyzguess f(mu)        0.0172093
 xyzguess n(mu)         0.144000
-xyzguess c(mu)       0.00179401 
+xyzguess c(mu)       0.00179401
 
 xyzguess x(pa)         0.501982
 xyzguess y(pa)         0.998030
@@ -153,7 +152,7 @@ xyzguess m(opx)           0.001
 xyzguess y(opx)        0.128377  range  0.000 2.000
 xyzguess f(opx)            0.01
 xyzguess c(opx)            0.01
-xyzguess Q(opx)        0.216433 
+xyzguess Q(opx)        0.216433
 
 xyzguess x(sa)            0.1
 xyzguess y(sa)            0.3
@@ -181,13 +180,13 @@ xyzguess x(ctd)        0.990857
 xyzguess m(ctd)           0.001
 xyzguess f(ctd)            0.01
 
-xyzguess x(sp)    0.6    
-xyzguess y(sp)    0.95   
-xyzguess z(sp)    0.01  
+xyzguess x(sp)    0.6
+xyzguess y(sp)    0.95
+xyzguess z(sp)    0.01
 
-xyzguess x(mt)    0.85    
-xyzguess y(mt)    0.05   
-xyzguess z(mt)    0.01  
+xyzguess x(mt)    0.85
+xyzguess y(mt)    0.05
+xyzguess z(mt)    0.01
 
 xyzguess i(ilmm)       0.858568
 xyzguess g(ilmm)      0.0294376
@@ -199,11 +198,11 @@ xyzguess g(hemm)     0.00296953
 xyzguess m(hemm)      0.0305831
 xyzguess Q(hemm)     -0.0102634  range -0.300 0.300
 
-xyzguess x(ilm)       0.80           
+xyzguess x(ilm)       0.80
 xyzguess Q(ilm)       0.01       range -0.990 0.990
 
-xyzguess x(hem)       0.20           
-xyzguess Q(hem)       0.8        range -0.99 0.99   
+xyzguess x(hem)       0.20
+xyzguess Q(hem)       0.8        range -0.99 0.99
 
 xyzguess x(mt1)        0.632160
 xyzguess Q(mt1)        0.564334

{pypsbuilder-2.6.6 → pypsbuilder-2.6.8}/pypsbuilder/__init__.py

@@ -22,7 +22,7 @@ __all__ = (
     "get_tcapi",
 )
 
-__version__ = "2.6.6"
+__version__ = "2.6.8"
 __author__ = "Ondrej Lexa"
 __copyright__ = "© Ondrej Lexa 2016-2025"
 __email__ = "lexa.ondrej@gmail.com"

{pypsbuilder-2.6.6 → pypsbuilder-2.6.8}/pypsbuilder/psbuilders.py

@@ -81,6 +81,10 @@ app_icons = dict(
     PXBuilder="images/pxbuilder.png",
 )
 
+# maps a section's x_var/y_var ("T"/"p"/"C") to the JSON entry key that
+# carries that axis's [min, max] span ("T"/"P"/"X")
+json_key_for_var = {"T": "T", "p": "P", "C": "X"}
+
 
 class BuildersBase(QtWidgets.QMainWindow):
     """Main base class for pseudosection builders."""
@@ -96,7 +100,9 @@ class BuildersBase(QtWidgets.QMainWindow):
         )
         self.setWindowIcon(QtGui.QIcon(window_icon))
         self.__changed = False
-        self.about_dialog = AboutDialog(self.builder_name, __version__, __copyright__)
+        self.about_dialog = AboutDialog(
+            self.builder_name, __version__, __copyright__, window_icon, parent=self
+        )
         self.unihigh = None
         self.invhigh = None
         self.outhigh = None
@@ -274,6 +280,7 @@ class BuildersBase(QtWidgets.QMainWindow):
         self.actionAbout.triggered.connect(self.about_dialog.exec)
         self.actionImport_project.triggered.connect(self.import_from_prj)
         self.actionImport_json.triggered.connect(lambda: self.import_from_json())
+        self.actionExport_json.triggered.connect(lambda: self.export_to_json())
         self.actionCleanup.triggered.connect(self.cleanup_storage)
         self.actionFixphase.triggered.connect(self.fix_phasenames)
         self.actionShow_areas.triggered.connect(self.check_prj_areas)
@@ -701,16 +708,70 @@ class BuildersBase(QtWidgets.QMainWindow):
                 entry["out"] = [mapping.get(p, p) for p in entry.get("out", [])]
         return True
 
+    def _entry_xy(self, entry):
+        """Midpoint (x, y) of a JSON inv/uni entry in diagram (ps.xrange/yrange) units."""
+        xv = entry.get(json_key_for_var[self.ps.x_var])
+        yv = entry.get(json_key_for_var[self.ps.y_var])
+        if xv is None or yv is None:
+            return None, None
+        return sum(xv) / 2, sum(yv) / 2
+
+    def _nearest_invpoint(self, x, y):
+        """Closest existing InvPoint to (x, y), distance normalized by
+        ps.xrange/yrange, or None if there's nothing to compare against.
+        """
+        if x is None or y is None or not self.ps.invpoints:
+            return None
+        xspan = self.ps.xrange[1] - self.ps.xrange[0]
+        yspan = self.ps.yrange[1] - self.ps.yrange[0]
+        if xspan <= 0 or yspan <= 0:
+            return None
+        return min(
+            self.ps.invpoints.values(),
+            key=lambda inv: ((inv._x - x) / xspan) ** 2 + ((inv._y - y) / yspan) ** 2,
+        )
+
+    def _seed_guess_from_nearest(self, entry):
+        """Seed the scriptfile's ptguesses from the nearest already-calculated
+        invariant point to this JSON entry, mirroring invsel_guesses's manual
+        `update_scriptfile(guesses=inv.ptguess())` pattern.
+        """
+        nearest = self._nearest_invpoint(*self._entry_xy(entry))
+        if nearest is not None:
+            self.tc.update_scriptfile(guesses=nearest.ptguess())
+
+    def _autoconnect_inv(self, inv, id_inv):
+        """Connect any univariant line that now has both its endpoints
+        calculated, mirroring the manual autoconnect behavior.
+        """
+        for uni in self.ps.unilines.values():
+            if uni.contains_inv(inv):
+                candidates = [inv]
+                for other_inv in self.ps.invpoints.values():
+                    if other_inv.id != id_inv and uni.contains_inv(other_inv):
+                        candidates.append(other_inv)
+                if len(candidates) == 2:
+                    self.uni_connect(uni.id, candidates)
+
+    def _import_step_count(self, span, full_span):
+        """Step count so the physical step used for a JSON-imported univariant
+        line is never finer than 1/200 of the full pseudosection range for
+        the axis being stepped (a floor on step size), capped at
+        spinSteps.value().
+        """
+        if full_span <= 0 or span <= 0:
+            return self.spinSteps.value()
+        min_step = full_span / 200
+        max_steps = int(span / min_step)
+        return max(min(self.spinSteps.value(), max_steps), 1)
+
     def import_from_json(self, jsonfile=None, phase_map=None):
-        if not (
-            self.ready and len(self.ps.invpoints) == 0 and len(self.ps.unilines) == 0
-        ):
+        if not self.ready:
             qb = QtWidgets.QMessageBox
             qb.critical(
                 self,
                 "Cannot import",
-                "Import from JSON requires an initialized, empty project "
-                "(no invariant points or univariant lines yet).",
+                "Import from JSON requires an initialized project.",
                 qb.StandardButton.Abort,
             )
             return
@@ -747,10 +808,14 @@ class BuildersBase(QtWidgets.QMainWindow):
         n_uni_ok = n_uni_fail = n_uni_dup = 0
         QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.CursorShape.WaitCursor)
         try:
+            # Round 1: attempt every new invariant point once. Entries that
+            # fail are retried in round 2 below, once other points from this
+            # same import are available as nearby ptguess seeds.
             n = len(data["inv"])
+            retry = []
             for i, entry in enumerate(data["inv"]):
                 self.statusBar().showMessage(
-                    "Importing invariant point {}/{}...".format(i + 1, n)
+                    "Importing invariant point {}/{} (round 1)...".format(i + 1, n)
                 )
                 QtWidgets.QApplication.processEvents()
                 try:
@@ -766,6 +831,27 @@ class BuildersBase(QtWidgets.QMainWindow):
                 if not isnew:
                     n_inv_dup += 1
                     continue
+                self._seed_guess_from_nearest(entry)
+                inv = self._import_calc_inv(inv_tmp.phases, inv_tmp.out)
+                if inv is None:
+                    retry.append((id_inv, inv_tmp, entry))
+                    continue
+                self.invmodel.appendRow(id_inv, inv)
+                n_inv_ok += 1
+                if self.checkAutoconnectInv.isChecked():
+                    self._autoconnect_inv(inv, id_inv)
+                self.plot()
+
+            # Round 2: retry points that failed in round 1, now that any
+            # points calculated in round 1 are available as nearby ptguess
+            # seeds too.
+            n = len(retry)
+            for i, (id_inv, inv_tmp, entry) in enumerate(retry):
+                self.statusBar().showMessage(
+                    "Importing invariant point {}/{} (round 2)...".format(i + 1, n)
+                )
+                QtWidgets.QApplication.processEvents()
+                self._seed_guess_from_nearest(entry)
                 inv = self._import_calc_inv(inv_tmp.phases, inv_tmp.out)
                 if inv is None:
                     n_inv_fail += 1
@@ -773,16 +859,8 @@ class BuildersBase(QtWidgets.QMainWindow):
                 self.invmodel.appendRow(id_inv, inv)
                 n_inv_ok += 1
                 if self.checkAutoconnectInv.isChecked():
-                    for uni in self.ps.unilines.values():
-                        if uni.contains_inv(inv):
-                            candidates = [inv]
-                            for other_inv in self.ps.invpoints.values():
-                                if other_inv.id != id_inv and uni.contains_inv(
-                                    other_inv
-                                ):
-                                    candidates.append(other_inv)
-                            if len(candidates) == 2:
-                                self.uni_connect(uni.id, candidates)
+                    self._autoconnect_inv(inv, id_inv)
+                self.plot()
 
             n = len(data["uni"])
             for j, entry in enumerate(data["uni"]):
@@ -803,6 +881,7 @@ class BuildersBase(QtWidgets.QMainWindow):
                 if not isnew:
                     n_uni_dup += 1
                     continue
+                self._seed_guess_from_nearest(entry)
                 uni = self._import_calc_uni(uni_tmp.phases, uni_tmp.out, entry)
                 if uni is None:
                     n_uni_fail += 1
@@ -814,13 +893,13 @@ class BuildersBase(QtWidgets.QMainWindow):
                 n_uni_ok += 1
                 if self.checkAutoconnectUni.isChecked() and len(candidates) == 2:
                     self.uni_connect(id_uni, candidates)
+                self.plot()
         finally:
             QtWidgets.QApplication.restoreOverrideCursor()
 
         self.changed = True
         self.invview.resizeColumnsToContents()
         self.uniview.resizeColumnsToContents()
-        self.plot()
         summary = (
             "Imported {}/{} invariant points and {}/{} univariant lines from JSON."
         ).format(n_inv_ok, len(data["inv"]), n_uni_ok, len(data["uni"]))
@@ -834,6 +913,73 @@ class BuildersBase(QtWidgets.QMainWindow):
             ).format(n_inv_dup, n_uni_dup)
         self.statusBar().showMessage(summary)
 
+    def _build_export_json(self):
+        """Build the JSON-serializable dict of current invariant points and
+        univariant lines. Kept free of Qt/file I/O so it can be tested
+        directly against a duck-typed stand-in for self.
+        """
+        kind_map = {"PTBuilder": "PT", "TXBuilder": "TX", "PXBuilder": "PX"}
+        kind = kind_map[self.builder_name]
+
+        def axes(x0, x1, y0, y1):
+            if kind == "PT":
+                return {"P": [y0, y1], "T": [x0, x1], "X": None}
+            elif kind == "TX":
+                return {"P": None, "T": [x0, x1], "X": [y0, y1]}
+            else:  # PX
+                return {"P": [y0, y1], "T": None, "X": [x0, x1]}
+
+        if kind == "TX":
+            P = float(sum(self.tc.prange) / 2)
+            T = [float(v) for v in self.ps.xrange]
+        elif kind == "PX":
+            P = [float(v) for v in self.ps.yrange]
+            T = float(sum(self.tc.trange) / 2)
+        else:
+            P = [float(v) for v in self.ps.yrange]
+            T = [float(v) for v in self.ps.xrange]
+
+        inv_list = []
+        for inv in self.ps.invpoints.values():
+            entry = axes(inv._x, inv._x, inv._y, inv._y)
+            entry["phases"] = sorted(inv.phases)
+            entry["out"] = sorted(inv.out)
+            inv_list.append(entry)
+
+        uni_list = []
+        for uni in self.ps.unilines.values():
+            entry = axes(
+                float(uni.x.min()),
+                float(uni.x.max()),
+                float(uni.y.min()),
+                float(uni.y.max()),
+            )
+            entry["phases"] = sorted(uni.phases)
+            entry["out"] = sorted(uni.out)
+            uni_list.append(entry)
+
+        return {"kind": kind, "P": P, "T": T, "inv": inv_list, "uni": uni_list}
+
+    def export_to_json(self):
+        if not self.ready:
+            self.statusBar().showMessage("Project is not yet initialized.")
+            return
+        filename = QtWidgets.QFileDialog.getSaveFileName(
+            self, "Export to JSON", str(self.tc.workdir), "JSON file (*.json)"
+        )[0]
+        if not filename:
+            return
+        if not filename.lower().endswith(".json"):
+            filename = filename + ".json"
+        data = self._build_export_json()
+        with open(filename, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+        self.statusBar().showMessage(
+            "Exported {} invariant points and {} univariant lines to {}".format(
+                len(data["inv"]), len(data["uni"]), filename
+            )
+        )
+
     def cleanup_storage(self):
         if self.ready:
             qb = QtWidgets.QMessageBox
@@ -1057,10 +1203,12 @@ class BuildersBase(QtWidgets.QMainWindow):
     def show_output(self, int):
         if self.ready:
             if int == 0:
-                dia = OutputDialog("Modes", self.textOutput.toPlainText())
+                dia = OutputDialog("Modes", self.textOutput.toPlainText(), parent=self)
                 dia.exec()
             if int == 1:
-                dia = OutputDialog("TC output", self.textFullOutput.toPlainText())
+                dia = OutputDialog(
+                    "TC output", self.textFullOutput.toPlainText(), parent=self
+                )
                 dia.exec()
 
     def toolbar_mode_name(self):
@@ -3126,12 +3274,22 @@ class PTBuilder(BuildersBase, Ui_PTBuilder):
             results=res,
         )
 
+    def _uni_calc_strategy(self, p0, p1, t0, t1):
+        """ "calc_p" (steps T, calctatp no) or "calc_t" (steps P, calctatp
+        yes) for a JSON-imported univariant line spanning [p0, p1] x
+        [t0, t1]: step through whichever axis spans proportionally more of
+        the full pseudosection range - i.e. the axis the line runs along
+        more, as plotted - and solve for the other.
+        """
+        ratio_P = (p1 - p0) / (self.tc.prange[1] - self.tc.prange[0])
+        ratio_T = (t1 - t0) / (self.tc.trange[1] - self.tc.trange[0])
+        return "calc_p" if ratio_P < ratio_T else "calc_t"
+
     def _import_calc_uni(self, phases, out, entry):
         try:
-            p0, p1 = entry["P"]
-            t0, t1 = entry["T"]
-            ratio_P = (p1 - p0) / (self.tc.prange[1] - self.tc.prange[0])
-            ratio_T = (t1 - t0) / (self.tc.trange[1] - self.tc.trange[0])
+            p0, p1 = sorted(entry["P"])
+            t0, t1 = sorted(entry["T"])
+            strategy = self._uni_calc_strategy(p0, p1, t0, t1)
         except (KeyError, TypeError, ValueError, ZeroDivisionError):
             return None
         # extend by 10% of the JSON line's own P/T span to minimize
@@ -3140,13 +3298,19 @@ class PTBuilder(BuildersBase, Ui_PTBuilder):
         text = 0.1 * (t1 - t0)
         prange = (max(p0 - pext, self.tc.prange[0]), min(p1 + pext, self.tc.prange[1]))
         trange = (max(t0 - text, self.tc.trange[0]), min(t1 + text, self.tc.trange[1]))
-        calc = self.tc.calc_p if ratio_P < ratio_T else self.tc.calc_t
+        calc = getattr(self.tc, strategy)
+        if strategy == "calc_p":
+            span = trange[1] - trange[0]
+            full_span = self.tc.trange[1] - self.tc.trange[0]
+        else:
+            span = prange[1] - prange[0]
+            full_span = self.tc.prange[1] - self.tc.prange[0]
         tcout, ans = calc(
             phases,
             out,
             prange=prange,
             trange=trange,
-            steps=self.spinSteps.value(),
+            steps=self._import_step_count(span, full_span),
         )
         status, res, output = self.tc.parse_logfile()
         if status in ("bombed", "nir") or len(res) < 2:
@@ -5647,12 +5811,28 @@ class UniGuess(QtWidgets.QDialog, Ui_UniGuess):
 class AboutDialog(QtWidgets.QDialog):
     """About dialog"""
 
-    def __init__(self, builder, version, copyright, parent=None):
+    def __init__(self, builder, version, copyright, icon=None, parent=None):
         """Display a dialog that shows application information."""
         super(AboutDialog, self).__init__(parent)
 
         self.setWindowTitle("About")
-        self.resize(300, 100)
+        self.resize(320, 220)
+        # keep the dialog above the main window (and everything else)
+        # instead of a plain modal QDialog, which some window managers can
+        # still push behind the parent window
+        self.setWindowFlags(
+            self.windowFlags() | QtCore.Qt.WindowType.WindowStaysOnTopHint
+        )
+
+        if icon is not None:
+            self.setWindowIcon(QtGui.QIcon(icon))
+            logo = QtWidgets.QLabel()
+            logo.setPixmap(
+                QtGui.QIcon(icon).pixmap(
+                    64, 64, QtGui.QIcon.Mode.Normal, QtGui.QIcon.State.On
+                )
+            )
+            logo.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
 
         title = QtWidgets.QLabel("{} {}".format(builder, version))
         title.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
@@ -5682,6 +5862,8 @@ class AboutDialog(QtWidgets.QDialog):
         self.layout = QtWidgets.QVBoxLayout()
         self.layout.setAlignment(QtCore.Qt.AlignmentFlag.AlignVCenter)
 
+        if icon is not None:
+            self.layout.addWidget(logo)
         self.layout.addWidget(title)
         self.layout.addWidget(suptitle)
         self.layout.addWidget(author)
@@ -5700,6 +5882,9 @@ class OutputDialog(QtWidgets.QDialog):
 
         self.setWindowTitle(title)
         self.resize(800, 600)
+        self.setWindowFlags(
+            self.windowFlags() | QtCore.Qt.WindowType.WindowStaysOnTopHint
+        )
 
         self.plainText = QtWidgets.QPlainTextEdit(self)
         self.plainText.setLineWrapMode(QtWidgets.QPlainTextEdit.LineWrapMode.NoWrap)

{pypsbuilder-2.6.6 → pypsbuilder-2.6.8}/pypsbuilder/tcapi.py

@@ -507,9 +507,10 @@ class TC35API(TCAPI):
                 # omit
                 errinfo = "Wrong omit in scriptfile."
                 if "omit" in scripts:
-                    self.omit = set(scripts["omit"][0].split())
+                    raise ScriptfileError("omit, is unrecognised (or discontinued).")
                 else:
                     self.omit = set()
+                errinfo = "Error in scriptfile."
                 # autoexit
                 if "autoexit" not in scripts:
                     raise ScriptfileError(
@@ -541,15 +542,21 @@ class TC35API(TCAPI):
                         "Dogmin script should be removed from scriptfile."
                     )
                 # union ax phases and samecoding and diff omit
-                if "BOMBED" in self.tcout:
-                    raise TCError(self.tcout.split("BOMBED")[1].split(os.linesep)[0])
-                else:
+                if "reading ax:" in self.tcout:
                     ax_phases = set(
                         self.tcout.split("reading ax:")[1]
                         .split(2 * os.linesep)[0]
                         .split()
                     )
                     self.phases = ax_phases.union(*self.samecoding) - self.omit
+                else:
+                    if "-- run bombed" in self.tcout:
+                        raise TCError(
+                            "-- run bombed"
+                            + self.tcout.split("-- run bombed")[1].split(os.linesep)[0]
+                        )
+                    else:
+                        raise TCError("Unspecified error")
                 # OK
                 self.status = "Initial check done."
                 self.OK = True
@@ -573,7 +580,7 @@ class TC35API(TCAPI):
             self.OK = False
 
     def parse_logfile(self, **kwargs):
-        """Parser for THERMOCALC 3.50beta output.
+        """Parser for THERMOCALC 3.51 output.
 
         It parses the outputs of THERMOCALC after calculation.