mechprops-extractor 0.1.0__tar.gz

mechprops_extractor-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wyatt Ho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mechprops_extractor-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: mechprops-extractor
+Version: 0.1.0
+Summary: Extract Young's modulus, ultimate point, and break-point from stress-strain curves
+Author-email: wyatthoho <wyatthoho@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Wyatt Ho
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/wyatthoho/mechprops-extractor
+Project-URL: Repository, https://github.com/wyatthoho/mechprops-extractor
+Keywords: stress-strain,mechanical-properties,materials-testing,youngs-modulus
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=2.3
+Requires-Dist: matplotlib>=3.10
+Requires-Dist: scipy>=1.16
+Dynamic: license-file
+
+# Mechanical Properties Extractor
+
+Extracts Young's modulus, ultimate point, and break-point properties from
+stress-strain curve data, via ISO 527 linear regression, a custom
+RMSProp-based curve fit, or break-point detection.
+
+## Features
+
+- Young's modulus via ISO 527 secant-line linear regression
+- Young's modulus via a custom RMSProp-based enclosed-area fit
+- Ultimate (peak stress) point detection on the stress-strain curve
+- Break-point (failure) detection on the stress-strain curve
+- Built-in plots and an animation of the RMSProp fitting process
+
+## Installation
+
+```bash
+pip install mechprops-extractor
+```
+
+For development (editable install):
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+Load a stress-strain CSV (`strain`, `stress` columns) into a `StressStrainCurve`,
+then call any combination of its analysis methods. The example below uses one
+of the sample datasets bundled in [`data/`](data):
+
+```python
+import pandas as pd
+
+from mechprops import StressStrainCurve
+
+df = pd.read_csv("data/polyimide-stress-strain.csv")
+curve = StressStrainCurve(df["strain"], df["stress"])
+
+curve.fit_modulus_iso527()      # Young's modulus via ISO 527 linear regression
+curve.fit_modulus_rmsprop()     # Young's modulus via RMSProp area minimization
+curve.find_ultimate_point()     # (strain, stress) at the ultimate (peak stress) point
+curve.find_break_point()        # (strain, stress) at the detected break point
+```
+
+Each method returns its computed value and, by default, opens a plot window
+illustrating the result — close it to continue. Pass `show=False` to skip the
+plot and get the value only.

mechprops_extractor-0.1.0/README.md

@@ -0,0 +1,49 @@
+# Mechanical Properties Extractor
+
+Extracts Young's modulus, ultimate point, and break-point properties from
+stress-strain curve data, via ISO 527 linear regression, a custom
+RMSProp-based curve fit, or break-point detection.
+
+## Features
+
+- Young's modulus via ISO 527 secant-line linear regression
+- Young's modulus via a custom RMSProp-based enclosed-area fit
+- Ultimate (peak stress) point detection on the stress-strain curve
+- Break-point (failure) detection on the stress-strain curve
+- Built-in plots and an animation of the RMSProp fitting process
+
+## Installation
+
+```bash
+pip install mechprops-extractor
+```
+
+For development (editable install):
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+Load a stress-strain CSV (`strain`, `stress` columns) into a `StressStrainCurve`,
+then call any combination of its analysis methods. The example below uses one
+of the sample datasets bundled in [`data/`](data):
+
+```python
+import pandas as pd
+
+from mechprops import StressStrainCurve
+
+df = pd.read_csv("data/polyimide-stress-strain.csv")
+curve = StressStrainCurve(df["strain"], df["stress"])
+
+curve.fit_modulus_iso527()      # Young's modulus via ISO 527 linear regression
+curve.fit_modulus_rmsprop()     # Young's modulus via RMSProp area minimization
+curve.find_ultimate_point()     # (strain, stress) at the ultimate (peak stress) point
+curve.find_break_point()        # (strain, stress) at the detected break point
+```
+
+Each method returns its computed value and, by default, opens a plot window
+illustrating the result — close it to continue. Pass `show=False` to skip the
+plot and get the value only.

mechprops_extractor-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mechprops-extractor"
+version = "0.1.0"
+description = "Extract Young's modulus, ultimate point, and break-point from stress-strain curves"
+authors = [{ name = "wyatthoho", email = "wyatthoho@gmail.com" }]
+dependencies = ["pandas >= 2.3", "matplotlib >= 3.10", "scipy >= 1.16"]
+requires-python = ">=3.12"
+readme = "README.md"
+license = { file = "LICENSE" }
+keywords = [
+    "stress-strain",
+    "mechanical-properties",
+    "materials-testing",
+    "youngs-modulus",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+]
+
+[project.urls]
+Homepage = "https://github.com/wyatthoho/mechprops-extractor"
+Repository = "https://github.com/wyatthoho/mechprops-extractor"
+
+[tool.setuptools]
+package-dir = { "" = "src" }

mechprops_extractor-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mechprops_extractor-0.1.0/src/mechprops/__init__.py

@@ -0,0 +1,3 @@
+from mechprops.curve import StressStrainCurve
+
+__all__ = ["StressStrainCurve"]

mechprops_extractor-0.1.0/src/mechprops/curve.py

@@ -0,0 +1,193 @@
+import numpy as np
+import pandas as pd
+from scipy import integrate, stats
+
+from mechprops.plotter import (
+    BreakDetectGraph,
+    Iso527Graph,
+    RmsPropAnimation,
+    UltimatePointGraph,
+)
+
+# Analysis Thresholds
+TINY_MODULUS = 1.0e-5
+CONVERGENCE_EPS = 1e-9
+BREAK_THRESHOLD = 0.1
+
+# RMSProp Hyperparameters
+RMS_PROP_BASE_LR = 0.01
+RMS_PROP_ALPHA = 0.9
+RMS_PROP_EPS = 1e-8
+
+# ISO-527
+STRAIN_LOWER = 0.0005
+STRAIN_UPPER = 0.0025
+
+# Modulus Fitting Defaults
+DEFAULT_TOL = 2.0e-5
+DEFAULT_MAX_ITER = 20_000
+
+
+class StressStrainCurve:
+    """Fits Young's modulus from a stress-strain curve, via ISO 527 linear
+    regression or a custom RMSProp-based enclosed-area minimization."""
+
+    def __init__(
+        self,
+        strain: pd.Series,
+        stress: pd.Series,
+    ) -> None:
+        self.strain_raw = strain
+        self.stress_raw = stress
+
+        idx = int(self.stress_raw.idxmax())
+        self.ultimate_x = float(self.strain_raw[idx])
+        self.ultimate_y = float(self.stress_raw[idx])
+
+        self.strain_norm = self.strain_raw / self.ultimate_x
+        self.stress_norm = self.stress_raw / self.ultimate_y
+
+    def find_ultimate_point(self, show: bool = True) -> tuple[float, float]:
+        """Returns the (strain, stress) at maximum stress, the ultimate
+        point of the curve.
+
+        Args:
+            show: Plots the ultimate point over the raw input curve.
+
+        Returns:
+            The (strain, stress) of the ultimate point in raw units.
+        """
+        ultimate_point = (self.ultimate_x, self.ultimate_y)
+        if show:
+            graph = UltimatePointGraph(self.strain_raw, self.stress_raw, ultimate_point)
+            graph.show()
+
+        return ultimate_point
+
+    def fit_modulus_iso527(self, show: bool = True) -> float:
+        """Fits modulus via ISO 527 linear regression over the
+        [STRAIN_LOWER, STRAIN_UPPER] strain range.
+
+        Args:
+            show: Plots the fitted secant line over the raw input curve.
+
+        Raises:
+            ValueError: Fewer than 2 raw strain samples fall in the range.
+        """
+        xs = self.strain_raw
+        ys = self.stress_raw
+
+        target = xs.between(STRAIN_LOWER, STRAIN_UPPER)
+        if target.sum() < 2:
+            raise ValueError("Not enough raw strain data in the range for regression.")
+
+        res = stats.linregress(xs[target], ys[target], "greater")
+        m = res.slope
+        shift = res.intercept
+
+        if show:
+            secant = m * xs + shift
+            graph = Iso527Graph(xs, ys, secant, m)
+            graph.show()
+
+        return m
+
+    def fit_modulus_rmsprop(
+        self,
+        tol: float = DEFAULT_TOL,
+        max_iter: int = DEFAULT_MAX_ITER,
+        show: bool = True,
+    ) -> float:
+        """Fits modulus by using RMSProp to minimize the area enclosed between
+        the normalized curve and its secant line.
+
+        Args:
+            tol: Stops iterating once the relative change in modulus is below this.
+            max_iter: Maximum number of RMSProp iterations to run.
+            show: Plays an animation of the fitting process.
+
+        Returns:
+            The fitted modulus, rescaled back to raw strain/stress units.
+        """
+        m = 1.0
+        v = 0.0
+
+        xs = self.strain_norm
+        ys = self.stress_norm
+
+        x0 = float(self.strain_norm.iloc[0])
+        y0 = float(self.stress_norm.iloc[0])
+
+        m_records = []
+        loss_records = []
+        lr_records = []
+
+        for _ in range(max_iter):
+            area = self._compute_enclosed_area(m, x0, y0, xs, ys)
+            area_eps = self._compute_enclosed_area(m + TINY_MODULUS, x0, y0, xs, ys)
+            gradient = (area_eps - area) / TINY_MODULUS
+            v, lr = self._update_rmsprop(v, gradient)
+
+            m_records.append(m)
+            loss_records.append(area)
+            lr_records.append(lr)
+
+            m_new = m - lr * gradient
+            if abs(m_new - m) / (abs(m) + CONVERGENCE_EPS) < tol:
+                break
+            m = m_new
+
+        m_scale = m * self.ultimate_y / self.ultimate_x
+
+        if show:
+            ani = RmsPropAnimation(xs, ys, m_records, lr_records, loss_records)
+            ani.play()
+
+        return m_scale
+
+    def find_break_point(
+        self,
+        threshold: float = BREAK_THRESHOLD,
+        show: bool = True,
+    ) -> tuple[float, float]:
+        """Locates the first point where the normalized stress curve's slope
+        drops below -threshold, signaling the specimen break.
+
+        Args:
+            threshold: Slope drop (in normalized stress per sample) that
+                signals a break.
+            show: Plots the detected break point over the normalized curve.
+
+        Returns:
+            The (strain, stress) of the break point in raw units, or the last
+            sample's coordinates if no break is detected.
+        """
+        xs = self.strain_norm
+        ys = self.stress_norm
+
+        gradient = -np.gradient(ys)
+        positions = np.where(gradient > threshold)[0]
+        position = int(positions[0]) if positions.size > 0 else -1
+        label = int(xs.index[position])
+
+        if show:
+            break_pt_norm = float(xs[label]), float(ys[label])
+            graph = BreakDetectGraph(xs, ys, gradient, threshold, break_pt_norm)
+            graph.show()
+
+        return float(self.strain_raw[label]), float(self.stress_raw[label])
+
+    @staticmethod
+    def _compute_enclosed_area(
+        m: float, x0: float, y0: float, xs: pd.Series, ys: pd.Series
+    ) -> float:
+        shift = y0 - m * x0
+        secant = m * xs + shift
+        clipped = np.clip(ys - secant, 0, None)
+        return float(integrate.trapezoid(clipped, xs))
+
+    @staticmethod
+    def _update_rmsprop(v: float, gradient: float) -> tuple[float, float]:
+        v_new = RMS_PROP_ALPHA * v + (1 - RMS_PROP_ALPHA) * (gradient**2)
+        lr = RMS_PROP_BASE_LR / (v_new**0.5 + RMS_PROP_EPS)
+        return v_new, lr

mechprops_extractor-0.1.0/src/mechprops/plotter.py

@@ -0,0 +1,379 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from matplotlib import animation
+from matplotlib.collections import PathCollection, PolyCollection
+from matplotlib.lines import Line2D
+from matplotlib.text import Annotation
+
+# Shared constants
+MARKER_SIZE = 49
+MARKER_ZORDER = 5
+LINE_WIDTH = 1.5
+SECANT_POSITION_DIVISOR = 50
+ANNOTATION_OFFSET_LEFT = (5, 0)
+ANNOTATION_OFFSET_RIGHT = (-10, 0)
+COLOR_BLUE = "tab:blue"
+COLOR_ORANGE = "tab:orange"
+
+# RmsPropAnimation constants
+FIG_SIZE_RMSPROP = (4.8, 6)
+HEIGHT_RATIOS_RMSPROP = [2.4, 0.8, 0.8]
+ANI_INTERVAL = 50
+FRAME_SIZE_REQUEST = 50
+ALPHA_FILL = 0.3
+COLOR_FILL = "lightsteelblue"
+PROGRESS_MARKER_EDGECOLOR = "white"
+
+# Iso527Graph constants
+FIG_SIZE_ISO527 = (4.8, 3.6)
+
+# UltimatePointGraph constants
+FIG_SIZE_ULTIMATE = (4.8, 3.6)
+
+# BreakDetectGraph constants
+FIG_SIZE_BREAK = (4.8, 4.8)
+HEIGHT_RATIOS_BREAK = [2.4, 0.8]
+
+Point = tuple[float, float]
+
+
+def _get_secant_line(modulus: float, strain: pd.Series, stress: pd.Series) -> pd.Series:
+    """Calculates a secant line pinned directly to the initial data point."""
+    intercept = stress.values[0] - modulus * strain.values[0]
+    return modulus * strain + intercept
+
+
+def _get_annotation_pos(strain: pd.Series, secant: pd.Series) -> Point:
+    """Determines a stable, indexed coordinate for placing text annotations."""
+    idx = max(1, len(strain) // SECANT_POSITION_DIVISOR)
+    return float(strain.iloc[idx]), float(secant.iloc[idx])
+
+
+def _show_figure(fig: plt.Figure) -> None:
+    """Displays only the given figure, leaving any other open figures untouched."""
+    fig.canvas.manager.show()
+    fig.canvas.mpl_connect("close_event", lambda _: fig.canvas.stop_event_loop())
+    fig.canvas.start_event_loop()
+
+
+class RmsPropAnimation:
+    """Animates the RMSProp fit: a moving secant line over the stress-strain
+    curve alongside the learning-rate and loss traces. Call play() to start."""
+
+    _fig: plt.Figure
+    _ax_norm: plt.Axes
+    _ax_lr: plt.Axes
+    _ax_loss: plt.Axes
+    _line_secant: Line2D
+    _ann_secant: Annotation
+    _lr_marker: PathCollection
+    _loss_marker: PathCollection
+    _fill: PolyCollection | None
+    _ani: animation.FuncAnimation | None
+    _rids: list[int]
+
+    def __init__(
+        self,
+        strain: pd.Series,
+        stress: pd.Series,
+        m_records: list[float],
+        lr_records: list[float],
+        loss_records: list[float],
+    ):
+        self.strain = strain
+        self.stress = stress
+        self.m_records = m_records
+        self.lr_records = lr_records
+        self.loss_records = loss_records
+
+        self._fig, axs = plt.subplots(
+            nrows=3,
+            ncols=1,
+            figsize=FIG_SIZE_RMSPROP,
+            tight_layout=True,
+            height_ratios=HEIGHT_RATIOS_RMSPROP,
+        )
+        self._ax_norm, self._ax_lr, self._ax_loss = axs
+
+        self._setup_norm_axis()
+        self._setup_lr_axis()
+        self._setup_loss_axis()
+        self._fill = None
+        self._ani = None
+        self._rids = []
+
+    def _setup_norm_axis(self) -> None:
+        self._ax_norm.plot(
+            self.strain,
+            self.stress,
+            label="Stress-Strain Curve",
+            linewidth=LINE_WIDTH,
+            color=COLOR_BLUE,
+        )
+
+        # Placeholder y=x line, overwritten with the real secant on the first animation frame
+        (self._line_secant,) = self._ax_norm.plot(
+            self.strain,
+            self.strain,
+            label="RMSProp Fit",
+            linewidth=LINE_WIDTH,
+            linestyle="--",
+            color=COLOR_ORANGE,
+        )
+        self._ann_secant = self._ax_norm.annotate(
+            text="",
+            xy=_get_annotation_pos(self.strain, self.strain),
+            xytext=ANNOTATION_OFFSET_LEFT,
+            textcoords="offset points",
+            color=COLOR_ORANGE,
+        )
+
+        self._ax_norm.legend()
+        self._ax_norm.set(
+            xlabel="Normalized Strain",
+            ylabel="Normalized Stress",
+            title="RMSProp Optimization",
+        )
+        self._ax_norm.grid(True)
+        self.initial_ybound = self._ax_norm.get_ybound()
+
+    def _setup_lr_axis(self) -> None:
+        self._ax_lr.semilogy(self.lr_records, linewidth=LINE_WIDTH, color=COLOR_BLUE)
+        self._lr_marker = self._ax_lr.scatter(
+            0,
+            self.lr_records[0],
+            facecolors=COLOR_ORANGE,
+            edgecolors=PROGRESS_MARKER_EDGECOLOR,
+            linewidth=LINE_WIDTH,
+            zorder=MARKER_ZORDER,
+            s=MARKER_SIZE,
+        )
+        self._ax_lr.set(xlabel="Iteration", ylabel="LR")
+        self._ax_lr.grid(True)
+
+    def _setup_loss_axis(self) -> None:
+        self._ax_loss.plot(self.loss_records, linewidth=LINE_WIDTH, color=COLOR_BLUE)
+        self._loss_marker = self._ax_loss.scatter(
+            0,
+            self.loss_records[0],
+            facecolors=COLOR_ORANGE,
+            edgecolors=PROGRESS_MARKER_EDGECOLOR,
+            linewidth=LINE_WIDTH,
+            zorder=MARKER_ZORDER,
+            s=MARKER_SIZE,
+        )
+        self._ax_loss.set(xlabel="Iteration", ylabel="Loss")
+        self._ax_loss.grid(True)
+
+    def _get_record_indices(self) -> list[int]:
+        total = len(self.m_records)
+        step = max(1, total // FRAME_SIZE_REQUEST)
+        return list(range((total - 1) % step, total, step))
+
+    def _update_frame(self, fid: int) -> None:
+        rid = self._rids[fid]
+        m = self.m_records[rid]
+        secant = _get_secant_line(m, self.strain, self.stress)
+
+        # Redraw secant profile line adjustments
+        self._line_secant.set_ydata(secant)
+        self._ann_secant.set_text(f"E = {m:.2f}")
+        self._ann_secant.xy = _get_annotation_pos(self.strain, secant)
+
+        # Update shaded regional error tracking
+        if self._fill:
+            self._fill.remove()
+
+        self._fill = self._ax_norm.fill_between(
+            x=self.strain,
+            y1=self.stress,
+            y2=secant,
+            where=(self.stress > secant),
+            alpha=ALPHA_FILL,
+            color=COLOR_FILL,
+        )
+
+        # Update dynamic progress indicator markers
+        self._lr_marker.set_offsets(np.array([[rid, self.lr_records[rid]]]))
+        self._loss_marker.set_offsets(np.array([[rid, self.loss_records[rid]]]))
+        self._ax_norm.set_ybound(*self.initial_ybound)
+
+    def play(self) -> None:
+        self._rids = self._get_record_indices()
+        self._ani = animation.FuncAnimation(
+            fig=self._fig,
+            func=self._update_frame,
+            frames=len(self._rids),
+            interval=ANI_INTERVAL,
+            blit=False,
+            repeat=False,
+        )
+        _show_figure(self._fig)
+
+
+class Iso527Graph:
+    """Renders the static ISO 527 stress-strain curve with the fitted secant
+    line. Call show() to display it."""
+
+    _fig: plt.Figure
+
+    def __init__(
+        self,
+        strain: pd.Series,
+        stress: pd.Series,
+        secant: pd.Series,
+        m: float,
+    ):
+        self._fig, ax = plt.subplots(figsize=FIG_SIZE_ISO527, tight_layout=True)
+
+        ax.plot(
+            strain,
+            stress,
+            label="Stress-Strain Curve",
+            linewidth=LINE_WIDTH,
+            color=COLOR_BLUE,
+        )
+        ybound = ax.get_ybound()
+
+        ax.plot(
+            strain,
+            secant,
+            label="ISO 527 Fit",
+            linewidth=LINE_WIDTH,
+            linestyle="--",
+            color=COLOR_ORANGE,
+        )
+
+        ax.annotate(
+            text=f"E = {m:.1f}",
+            xy=_get_annotation_pos(strain, secant),
+            xytext=ANNOTATION_OFFSET_LEFT,
+            textcoords="offset points",
+            color=COLOR_ORANGE,
+        )
+
+        ax.set(xlabel="Strain", ylabel="Stress", title="ISO 527 Regression")
+        ax.grid(True)
+        ax.set_ybound(*ybound)
+        ax.legend()
+
+    def show(self) -> None:
+        _show_figure(self._fig)
+
+
+class UltimatePointGraph:
+    """Renders the stress-strain curve with the ultimate (peak stress) point
+    marked. Call show() to display it."""
+
+    _fig: plt.Figure
+
+    def __init__(
+        self,
+        strain: pd.Series,
+        stress: pd.Series,
+        ultimate_point: Point,
+    ):
+        self._fig, ax = plt.subplots(figsize=FIG_SIZE_ULTIMATE, tight_layout=True)
+
+        ax.plot(
+            strain,
+            stress,
+            label="Stress-Strain Curve",
+            linewidth=LINE_WIDTH,
+            color=COLOR_BLUE,
+        )
+
+        ux, uy = ultimate_point
+        ax.scatter(
+            ux,
+            uy,
+            marker="^",
+            s=MARKER_SIZE,
+            c=COLOR_ORANGE,
+            label="Ultimate Point",
+            zorder=MARKER_ZORDER,
+        )
+        ax.annotate(
+            f"({ux:.2f}, {uy:.2f})",
+            xy=(ux, uy),
+            xytext=ANNOTATION_OFFSET_RIGHT,
+            textcoords="offset points",
+            ha="right",
+            va="center",
+            color=COLOR_ORANGE,
+        )
+
+        ax.set(xlabel="Strain", ylabel="Stress", title="Ultimate Point Detection")
+        ax.grid(True)
+        ax.legend()
+
+    def show(self) -> None:
+        _show_figure(self._fig)
+
+
+class BreakDetectGraph:
+    """Renders the stress-strain curve with the detected break point and its
+    underlying gradient trace. Call show() to display it."""
+
+    _fig: plt.Figure
+    _ax_norm: plt.Axes
+    _ax_break: plt.Axes
+
+    def __init__(
+        self,
+        strain: pd.Series,
+        stress: pd.Series,
+        bindex: np.ndarray,
+        threshold: float,
+        break_point: tuple[float, float],
+    ):
+        self._fig, axs = plt.subplots(
+            nrows=2,
+            ncols=1,
+            figsize=FIG_SIZE_BREAK,
+            tight_layout=True,
+            height_ratios=HEIGHT_RATIOS_BREAK,
+        )
+
+        self._ax_norm, self._ax_break = axs
+
+        self._ax_norm.plot(
+            strain,
+            stress,
+            label="Stress-Strain Curve",
+            linewidth=LINE_WIDTH,
+            color=COLOR_BLUE,
+        )
+
+        self._ax_norm.set(ylabel="Normalized Stress", title="Break Point Detection")
+        self._ax_norm.grid(True)
+
+        bx, by = break_point
+        self._ax_norm.scatter(
+            bx,
+            by,
+            marker="x",
+            s=MARKER_SIZE,
+            c=COLOR_ORANGE,
+            label="Break Point",
+            zorder=MARKER_ZORDER,
+        )
+        self._ax_norm.annotate(
+            f"({bx:.2f}, {by:.2f})",
+            xy=(bx, by),
+            xytext=ANNOTATION_OFFSET_RIGHT,
+            textcoords="offset points",
+            ha="right",
+            va="center",
+            color=COLOR_ORANGE,
+        )
+        self._ax_norm.legend()
+
+        self._ax_break.plot(strain, bindex)
+        self._ax_break.axhline(threshold, color=COLOR_ORANGE, linestyle="--")
+        self._ax_break.grid(True)
+        self._ax_break.set(xlabel="Normalized Strain", ylabel="Gradient")
+
+    def show(self) -> None:
+        _show_figure(self._fig)

mechprops_extractor-0.1.0/src/mechprops_extractor.egg-info/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: mechprops-extractor
+Version: 0.1.0
+Summary: Extract Young's modulus, ultimate point, and break-point from stress-strain curves
+Author-email: wyatthoho <wyatthoho@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Wyatt Ho
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/wyatthoho/mechprops-extractor
+Project-URL: Repository, https://github.com/wyatthoho/mechprops-extractor
+Keywords: stress-strain,mechanical-properties,materials-testing,youngs-modulus
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=2.3
+Requires-Dist: matplotlib>=3.10
+Requires-Dist: scipy>=1.16
+Dynamic: license-file
+
+# Mechanical Properties Extractor
+
+Extracts Young's modulus, ultimate point, and break-point properties from
+stress-strain curve data, via ISO 527 linear regression, a custom
+RMSProp-based curve fit, or break-point detection.
+
+## Features
+
+- Young's modulus via ISO 527 secant-line linear regression
+- Young's modulus via a custom RMSProp-based enclosed-area fit
+- Ultimate (peak stress) point detection on the stress-strain curve
+- Break-point (failure) detection on the stress-strain curve
+- Built-in plots and an animation of the RMSProp fitting process
+
+## Installation
+
+```bash
+pip install mechprops-extractor
+```
+
+For development (editable install):
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+Load a stress-strain CSV (`strain`, `stress` columns) into a `StressStrainCurve`,
+then call any combination of its analysis methods. The example below uses one
+of the sample datasets bundled in [`data/`](data):
+
+```python
+import pandas as pd
+
+from mechprops import StressStrainCurve
+
+df = pd.read_csv("data/polyimide-stress-strain.csv")
+curve = StressStrainCurve(df["strain"], df["stress"])
+
+curve.fit_modulus_iso527()      # Young's modulus via ISO 527 linear regression
+curve.fit_modulus_rmsprop()     # Young's modulus via RMSProp area minimization
+curve.find_ultimate_point()     # (strain, stress) at the ultimate (peak stress) point
+curve.find_break_point()        # (strain, stress) at the detected break point
+```
+
+Each method returns its computed value and, by default, opens a plot window
+illustrating the result — close it to continue. Pass `show=False` to skip the
+plot and get the value only.

mechprops_extractor-0.1.0/src/mechprops_extractor.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/mechprops/__init__.py
+src/mechprops/curve.py
+src/mechprops/plotter.py
+src/mechprops_extractor.egg-info/PKG-INFO
+src/mechprops_extractor.egg-info/SOURCES.txt
+src/mechprops_extractor.egg-info/dependency_links.txt
+src/mechprops_extractor.egg-info/requires.txt
+src/mechprops_extractor.egg-info/top_level.txt

mechprops_extractor-0.1.0/src/mechprops_extractor.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mechprops_extractor-0.1.0/src/mechprops_extractor.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pandas>=2.3
+matplotlib>=3.10
+scipy>=1.16

mechprops_extractor-0.1.0/src/mechprops_extractor.egg-info/top_level.txt

@@ -0,0 +1 @@
+mechprops