pypsbuilder 2.6.2__tar.gz → 2.6.4__tar.gz

pypsbuilder-2.6.4/.zenodo.json

@@ -0,0 +1,20 @@
+{
+    "creators": [
+        {
+            "name": "Lexa, Ondrej",
+            "orcid": "0000-0002-1825-0097",
+            "affiliation": "IPSG, Charles University, Prague, Czech Republic",
+            "type": "ProjectLeader"
+        }
+    ],
+    "title": "pypsbuilder - THERMOCALC front-end for constructing and visualizations of P-T, T-X and P-X pseudosections",
+    "access_right": "open",
+    "keywords": [
+        "metamorphic petrology",
+        "python",
+        "pseudosections"
+    ],
+    "license": "mit",
+    "upload_type": "software",
+    "language": "eng"
+}

{pypsbuilder-2.6.2 → pypsbuilder-2.6.4}/CHANGELOG.md

@@ -1,6 +1,16 @@
 # Changelog
 All notable pypsbuilder changes.
 
+## [2.6.4] - 2025-08-03
+### Fixed
+ - TC 3.51 compatibility added
+### Added
+ - `sys` could be used as phase to access G H S V rho variables
+
+## [2.6.3] - 2025-04-03
+### Fixed
+ - fixed multipolygon bug when subsections are merged
+
 ## [2.6.2] - 2025-02-11
 ### Fixed
  - f-string py3.10 bugfix

{pypsbuilder-2.6.2 → pypsbuilder-2.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pypsbuilder
-Version: 2.6.2
+Version: 2.6.4
 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
@@ -95,6 +95,11 @@ for Windows use Command Prompt or PowerShell:
     python -m venv .venv
     .venv\Scripts\activate
 
+or, if you will got error *'python' is not recognized as an internal or external command*, try:
+
+    py -m venv .venv
+    .venv\Scripts\activate
+
 > [!NOTE]
 > On Microsoft Windows, it may be required to set the execution policy in PowerShell for the user.
 > You can do this by issuing the following PowerShell command:

{pypsbuilder-2.6.2 → pypsbuilder-2.6.4}/README.md

@@ -19,6 +19,11 @@ for Windows use Command Prompt or PowerShell:
     python -m venv .venv
     .venv\Scripts\activate
 
+or, if you will got error *'python' is not recognized as an internal or external command*, try:
+
+    py -m venv .venv
+    .venv\Scripts\activate
+
 > [!NOTE]
 > On Microsoft Windows, it may be required to set the execution policy in PowerShell for the user.
 > You can do this by issuing the following PowerShell command:

{pypsbuilder-2.6.2 → pypsbuilder-2.6.4}/codecov.yml

@@ -1,5 +1,5 @@
 codecov:
-  require_ci_to_pass: yes
+  require_ci_to_pass: true
 
 coverage:
   precision: 2

{pypsbuilder-2.6.2 → pypsbuilder-2.6.4}/docs/api/pypsbuilder.tcapi.TC34API.rst

@@ -5,14 +5,14 @@
 
 .. autoclass:: TC34API
 
-   
+
    .. automethod:: __init__
 
-   
+
    .. rubric:: Methods
 
    .. autosummary::
-   
+
       ~TC34API.__init__
       ~TC34API.calc_assemblage
       ~TC34API.calc_p
@@ -31,15 +31,15 @@
       ~TC34API.rundr
       ~TC34API.runtc
       ~TC34API.update_scriptfile
-   
-   
 
-   
-   
+
+
+
+
    .. rubric:: Attributes
 
    .. autosummary::
-   
+
       ~TC34API.axfile
       ~TC34API.csvfile
       ~TC34API.dataset
@@ -52,7 +52,5 @@
       ~TC34API.ofile
       ~TC34API.prefsfile
       ~TC34API.scriptfile
-      ~TC34API.tcnewversion
+      ~TC34API.tcversionfloat
       ~TC34API.tcversion
-   
-   

{pypsbuilder-2.6.2 → pypsbuilder-2.6.4}/docs/api/pypsbuilder.tcapi.TC35API.rst

@@ -5,14 +5,14 @@
 
 .. autoclass:: TC35API
 
-   
+
    .. automethod:: __init__
 
-   
+
    .. rubric:: Methods
 
    .. autosummary::
-   
+
       ~TC35API.__init__
       ~TC35API.calc_assemblage
       ~TC35API.calc_p
@@ -30,15 +30,15 @@
       ~TC35API.rundr
       ~TC35API.runtc
       ~TC35API.update_scriptfile
-   
-   
 
-   
-   
+
+
+
+
    .. rubric:: Attributes
 
    .. autosummary::
-   
+
       ~TC35API.axfile
       ~TC35API.csvfile
       ~TC35API.dataset
@@ -51,7 +51,5 @@
       ~TC35API.ofile
       ~TC35API.prefsfile
       ~TC35API.scriptfile
-      ~TC35API.tcnewversion
+      ~TC35API.tcversionfloat
       ~TC35API.tcversion
-   
-   

{pypsbuilder-2.6.2 → pypsbuilder-2.6.4}/pypsbuilder/__init__.py

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

{pypsbuilder-2.6.2 → pypsbuilder-2.6.4}/pypsbuilder/psclasses.py

@@ -451,7 +451,7 @@ class TCResult:
             )
         # bulk composition
         bulk_vals = {}
-        oxhead, vals = bulk.split("\n")[1:]  # skip oxide compositions row
+        oxhead, vals = bulk.split("\n")[1:3]  # skip oxide compositions row
         for ox, val in zip(oxhead.split(), vals.split()[1:]):
             bulk_vals[ox] = float(val)
         data["bulk"] = bulk_vals
@@ -525,6 +525,109 @@ class TCResult:
         # Finally
         return cls(T, p, variance=variance, c=c, data=data, ptguess=ptguess)
 
+    @classmethod
+    def from_block351(cls, block, ptguess):
+        info, ax, sf, rbi, mode, factor, td, *mems, pems = block.split("\n\n")
+        bulk = "\n".join(rbi.split("\n")[:3])
+        rbi = "\n".join(rbi.split("\n")[3:])
+        # heading
+        data = {phase: {} for phase in info.split("{")[0].split()}
+        p, T = (float(v.strip()) for v in info.split("{")[1].split("}")[0].split(","))
+        # var or ovar?
+        variance = int(info.split("var = ")[1].split(" ")[0].replace(";", ""))
+        # a-x variables
+        for head, vals in zip(ax.split("\n")[::2], ax.split("\n")[1::2]):
+            phase, *names = head.split()
+            data[phase].update(
+                {
+                    name.replace("({})".format(phase), ""): float(val)
+                    for name, val in zip(names, vals.split())
+                }
+            )
+        # site fractions
+        for head, vals in zip(
+            sf.split("\n")[1::2], sf.split("\n")[2::2]
+        ):  # skip site fractions row
+            phase, *names = head.split()
+            data[phase].update(
+                {name: float(val) for name, val in zip(names, vals.split())}
+            )
+        # bulk composition
+        bulk_vals = {}
+        oxhead, vals = bulk.split("\n")[1:3]  # skip oxide compositions row
+        for ox, val in zip(oxhead.split(), vals.split()[1:]):
+            bulk_vals[ox] = float(val)
+        data["bulk"] = bulk_vals
+        # x for TX and pX
+        if "step" in vals:
+            c = float(vals.split("step")[1].split(", x =")[1])
+        else:
+            c = 0
+        # rbi
+        for row in rbi.split("\n"):
+            phase, *vals = row.split()
+            data[phase].update(
+                {ox: float(val) for ox, val in zip(oxhead.split(), vals)}
+            )
+        # modes (zero mode is empty field in tc350 !!!)
+        head, vals = mode.split("\n")
+        phases = head.split()[1:]
+        # fixed width parsing !!!
+        valsf = [
+            (
+                float(vals[6:][9 * i : 9 * (i + 1)].strip())
+                if vals[6:][9 * i : 9 * (i + 1)].strip() != ""
+                else 0.0
+            )
+            for i in range(len(phases))
+        ]
+        for phase, val in zip(phases, valsf):
+            data[phase].update({"mode": float(val)})
+        # factors
+        head, vals = factor.split("\n")
+        phases = head.split()[1:]
+        valsf = [
+            (
+                float(vals[6:][9 * i : 9 * (i + 1)].strip())
+                if vals[6:][9 * i : 9 * (i + 1)].strip() != ""
+                else 0.0
+            )
+            for i in range(len(phases))
+        ]
+        for phase, val in zip(phases, valsf):
+            data[phase].update({"factor": float(val)})
+        # thermodynamic state
+        head, *rows = td.split("\n")
+        for row in rows[:-1]:
+            phase, *vals = row.split()
+            data[phase].update(
+                {name: float(val) for name, val in zip(head.split(), vals)}
+            )
+        # bulk thermodynamics
+        sys = {}
+        for name, val in zip(head.split(), rows[-1].split()[1:]):
+            sys[name] = float(val)
+        data["sys"] = sys
+        # model end-members
+        if len(mems) > 0:
+            _, mem0 = mems[0].split("\n", maxsplit=1)
+            head = ["ideal", "gamma", "activity", "prop", "mu", "RTlna"]
+            mems[0] = mem0
+            for mem in mems:
+                ems = mem.split("\n")
+                phase, ems0 = ems[0].split(maxsplit=1)
+                ems[0] = ems0
+                for row in ems:
+                    em, *vals = row.split()
+                    phase_em = "{}({})".format(phase, em)
+                    data[phase_em] = {name: float(val) for name, val in zip(head, vals)}
+        # pure end-members
+        for row in pems.split("\n")[:-1]:
+            pem, val = row.split()
+            data[pem].update({"mu": float(val)})
+        # Finally
+        return cls(T, p, variance=variance, c=c, data=data, ptguess=ptguess)
+
     def __repr__(self):
         return "p:{:g} T:{:g} V:{} c:{:g}, Phases: {}".format(
             self.p, self.T, self.variance, self.c, " ".join(self.phases)
@@ -815,20 +918,20 @@ class SectionBase:
         def splitme(edges):
             """Recursive boundary splitter"""
             for idx, edge in enumerate(edges):
-                for _, l in lns:
-                    if edge.intersects(l):
-                        m = linemerge([edge, l])
+                for _, ln in lns:
+                    if edge.intersects(ln):
+                        m = linemerge([edge, ln])
                         if m.geom_type == "MultiLineString":
-                            p = edge.intersection(l)
+                            p = edge.intersection(ln)
                             if (
                                 p.geom_type == "LineString"
                             ):  # seems to occur whe duplicate points are on line
                                 p = MultiPoint(p.coords)
                             if p.geom_type == "MultiPoint":
-                                pts = [l.interpolate(l.project(pt)) for pt in p.geoms]
+                                pts = [ln.interpolate(ln.project(pt)) for pt in p.geoms]
                                 pts = sorted(pts, key=lambda pt: edge.project(pt))
                             else:
-                                pts = [l.interpolate(l.project(p))]
+                                pts = [ln.interpolate(ln.project(p))]
                             edges.pop(idx)
                             pts = (
                                 [Point(edge.coords[0])] + pts + [Point(edge.coords[-1])]
@@ -858,7 +961,7 @@ class SectionBase:
         while do:
             edges, do = splitme(edges)
         # polygonize
-        polys = list(polygonize(edges + [l for _, l in lns]))
+        polys = list(polygonize(edges + [ln for _, ln in lns]))
         # create shapes
         shapes = {}
         unilists = {}

{pypsbuilder-2.6.2 → pypsbuilder-2.6.4}/pypsbuilder/psexplorer.py

@@ -245,7 +245,7 @@ class PS:
         for comp in (
             set(self.all_data_keys.keys())
             .difference(self.phases)
-            .difference(set(["bulk", "sys"]))
+            .difference({'sys'})
         ):
             k, v = comp.split(")")[0].split("(")
             if k in em:
@@ -434,6 +434,7 @@ class PS:
         #             if len(res) > 0:
         #                 for k in res[0]['data'].keys():
         #                     data[k] = list(res[0]['data'][k].keys())
+        data['sys'] = ['G', 'H', 'S', 'V', 'rho']
         self.all_data_keys = data
 
     def collect_inv_data(self, key, phase, expr):
@@ -612,7 +613,7 @@ class PS:
         mn, mx = sys.float_info.max, -sys.float_info.max
         recs = OrderedDict()
         for key in self:
-            if phase.split("(")[0] in key:
+            if phase.split("(")[0] in key or phase == "sys":
                 d = self.collect_data(key, phase, expr, which=which)
                 z = d["data"]
                 if z:
@@ -700,13 +701,18 @@ class PS:
                     show = False
                 ax = fig.add_subplot()
             for k, shape in self.shapes.items():
-                patch = PolygonPatch(
-                    shape, fc=pscmap(norm(self.variance[k])), ec="none"
-                )
-                ax.add_patch(patch)
-                if show_vertices:
-                    x, y = zip(*patch.get_path().vertices)
-                    ax.plot(x, y, "k.", ms=3)
+                if shape.geom_type == "MultiPolygon":
+                    shapelist = list(shape.geoms)
+                else:
+                    shapelist = [shape]
+                for shape in shapelist:
+                    patch = PolygonPatch(
+                        shape, fc=pscmap(norm(self.variance[k])), ec="none"
+                    )
+                    ax.add_patch(patch)
+                    if show_vertices:
+                        x, y = zip(*patch.get_path().vertices)
+                        ax.plot(x, y, "k.", ms=3)
             ax.autoscale_view()
             self.add_overlay(ax, label=label, skiplabels=skiplabels, fontsize=labelfs)
             if out:
@@ -831,27 +837,42 @@ class PS:
     def add_overlay(self, ax, fc="none", ec="k", label=False, skiplabels=0, fontsize=6):
         area = (self.xrange[1] - self.xrange[0]) * (self.yrange[1] - self.yrange[0])
         for k, shape in self.shapes.items():
-            ax.add_patch(PolygonPatch(shape, ec=ec, fc=fc, lw=0.5))
-            if label and (100 * shape.area / area > skiplabels):
-                # multiline for long labels
-                tl = sorted(list(k.difference(self.tc.excess)))
-                extra = self.tc.excess.difference(self.tc.excess.intersection(k))
-                # if excess in scriptfile is not accurate
-                if extra:
-                    tl += ["-{}".format(pp) for pp in extra]
-                wp = len(tl) // 4 + int(len(tl) % 4 > 1)
-                txt = "\n".join(
-                    [
-                        " ".join([self.abbr.get(sa, sa) for sa in s])
-                        for s in [
-                            tl[i * len(tl) // wp : (i + 1) * len(tl) // wp]
-                            for i in range(wp)
+            if shape.geom_type == "MultiPolygon":
+                shapelist = list(shape.geoms)
+            else:
+                shapelist = [shape]
+            for shape in shapelist:
+                ax.add_patch(PolygonPatch(shape, ec=ec, fc=fc, lw=0.5))
+                if label and (100 * shape.area / area > skiplabels):
+                    # multiline for long labels
+                    tl = sorted(list(k.difference(self.tc.excess)))
+                    extra = self.tc.excess.difference(self.tc.excess.intersection(k))
+                    # if excess in scriptfile is not accurate
+                    if extra:
+                        tl += ["-{}".format(pp) for pp in extra]
+                    wp = len(tl) // 4 + int(len(tl) % 4 > 1)
+                    txt = "\n".join(
+                        [
+                            " ".join([self.abbr.get(sa, sa) for sa in s])
+                            for s in [
+                                tl[i * len(tl) // wp : (i + 1) * len(tl) // wp]
+                                for i in range(wp)
+                            ]
                         ]
-                    ]
-                )
-                if shape.geom_type == "MultiPolygon":
-                    for part in shape:
-                        xy = part.representative_point().coords[0]
+                    )
+                    if shape.geom_type == "MultiPolygon":
+                        for part in shape:
+                            xy = part.representative_point().coords[0]
+                            ax.annotate(
+                                text=txt,
+                                xy=xy,
+                                weight="bold",
+                                fontsize=fontsize,
+                                ha="center",
+                                va="center",
+                            )
+                    else:
+                        xy = shape.representative_point().coords[0]
                         ax.annotate(
                             text=txt,
                             xy=xy,
@@ -860,16 +881,6 @@ class PS:
                             ha="center",
                             va="center",
                         )
-                else:
-                    xy = shape.representative_point().coords[0]
-                    ax.annotate(
-                        text=txt,
-                        xy=xy,
-                        weight="bold",
-                        fontsize=fontsize,
-                        ha="center",
-                        va="center",
-                    )
 
     def show_data(self, key, phase, expr=None, which=7):
         """Convinient function to show values of expression
@@ -1325,6 +1336,7 @@ class PS:
                 Default False.
             labelkeys (frozenset or list): Keys of divariant fields where contours
                 should be labeled.
+            clabelfs (int): Contour labels font size. Default 9
             nosplit (bool): Controls whether the contour underlying labels are
                 removed or not. Defaut True
             gradient (bool): Whether the first derivate of values should be used.
@@ -1425,7 +1437,7 @@ class PS:
                 ax = fig.add_subplot()
             for key in recs:
                 phase_parts = phase.split(")")[0].split("(")
-                if phase_parts[0] in key:
+                if phase_parts[0] in key or phase == "sys":
                     tmin, pmin, tmax, pmax = self.shapes[key].bounds
                     # ttspace = self.xspace[np.logical_and(self.xspace >= tmin - self.xstep, self.xspace <= tmax + self.xstep)]
                     # ppspace = self.yspace[np.logical_and(self.yspace >= pmin - self.ystep, self.yspace <= pmax + self.ystep)]
@@ -1556,57 +1568,62 @@ class PS:
                         else:
                             cntv = 10
                     # ------------
-                    with warnings.catch_warnings():
-                        warnings.filterwarnings("ignore", category=UserWarning)
-                        if filled:
-                            if colors is not None:
-                                cont = ax.contourf(
-                                    tg, pg, zg, cntv, colors=colors, alpha=alpha
-                                )
-                                if filled_over:
-                                    contover = ax.contour(
-                                        tg, pg, zg, cntv, colors=colors
+                    if self.shapes[key].geom_type == "MultiPolygon":
+                        shapelist = list(self.shapes[key].geoms)
+                    else:
+                        shapelist = [self.shapes[key]]
+                    for shape in shapelist:
+                        with warnings.catch_warnings():
+                            warnings.filterwarnings("ignore", category=UserWarning)
+                            if filled:
+                                if colors is not None:
+                                    cont = ax.contourf(
+                                        tg, pg, zg, cntv, colors=colors, alpha=alpha
                                     )
-                            else:
-                                cont = ax.contourf(
-                                    tg, pg, zg, cntv, cmap=cmap, alpha=alpha
-                                )
-                                if filled_over:
-                                    contover = ax.contour(
-                                        tg, pg, zg, cntv, colors="whitesmoke"
+                                    if filled_over:
+                                        contover = ax.contour(
+                                            tg, pg, zg, cntv, colors=colors
+                                        )
+                                else:
+                                    cont = ax.contourf(
+                                        tg, pg, zg, cntv, cmap=cmap, alpha=alpha
                                     )
-                        else:
-                            if colors is not None:
-                                cont = ax.contour(tg, pg, zg, cntv, colors=colors)
+                                    if filled_over:
+                                        contover = ax.contour(
+                                            tg, pg, zg, cntv, colors="whitesmoke"
+                                        )
                             else:
-                                cont = ax.contour(tg, pg, zg, cntv, cmap=cmap)
-                    patch = PolygonPatch(self.shapes[key], fc="none", ec="none")
-                    ax.add_patch(patch)
-                    # label if needed
-                    if (not filled or filled_over) and key in labelkyes_ok:
-                        positions = []
-                        contlbl = contover if filled_over else cont
-                        for seg in contlbl.get_paths():
-                            inside = np.fromiter(
-                                map(
-                                    self.shapes[key].contains,
-                                    MultiPoint(seg.vertices).geoms,
-                                ),
-                                dtype=bool,
+                                if colors is not None:
+                                    cont = ax.contour(tg, pg, zg, cntv, colors=colors)
+                                else:
+                                    cont = ax.contour(tg, pg, zg, cntv, cmap=cmap)
+                        patch = PolygonPatch(shape, fc="none", ec="none")
+                        ax.add_patch(patch)
+                        # label if needed
+                        if (not filled or filled_over) and key in labelkyes_ok:
+                            positions = []
+                            contlbl = contover if filled_over else cont
+                            for seg in contlbl.get_paths():
+                                inside = np.fromiter(
+                                    map(
+                                        shape.contains,
+                                        MultiPoint(seg.vertices).geoms,
+                                    ),
+                                    dtype=bool,
+                                )
+                                if np.any(inside):
+                                    positions.append(seg.vertices[inside].mean(axis=0))
+                            ax.clabel(
+                                contlbl,
+                                fontsize=kwargs.get("clabelfs", 9),
+                                manual=positions,
+                                fmt="%g",
+                                inline_spacing=3,
+                                inline=not nosplit,
                             )
-                            if np.any(inside):
-                                positions.append(seg.vertices[inside].mean(axis=0))
-                        ax.clabel(
-                            contlbl,
-                            fontsize=9,
-                            manual=positions,
-                            fmt="%g",
-                            inline_spacing=3,
-                            inline=not nosplit,
-                        )
-                    cont.set_clip_path(patch)
-                    if filled and filled_over:
-                        contover.set_clip_path(patch)
+                        cont.set_clip_path(patch)
+                        if filled and filled_over:
+                            contover.set_clip_path(patch)
 
             if only is None:
                 self.add_overlay(ax)
@@ -2720,7 +2737,9 @@ class PTPS(PS):
         )
         plt.show()
 
-    def pointcalc(self, t=None, p=None, label=False, skiplabels=0, labelfs=6, show_output=False):
+    def pointcalc(
+        self, t=None, p=None, label=False, skiplabels=0, labelfs=6, show_output=False
+    ):
         if t is None or p is None:
             fig, ax = plt.subplots()
             ax.autoscale_view()