steer-core 0.1.22__tar.gz → 0.1.24__tar.gz

{steer_core-0.1.22 → steer_core-0.1.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steer-core
-Version: 0.1.22
+Version: 0.1.24
 Summary: Modelling energy storage from cell to site - STEER OpenCell Design
 Home-page: https://github.com/nicholas9182/steer-core/
 Author: Nicholas Siemons
@@ -12,8 +12,8 @@ Requires-Python: >=3.10
 Requires-Dist: pandas==2.1.4
 Requires-Dist: numpy==1.26.4
 Requires-Dist: datetime==5.5
-Requires-Dist: scipy==1.15.3
 Requires-Dist: plotly==6.2.0
+Requires-Dist: scipy==1.15.3
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{steer_core-0.1.22 → steer_core-0.1.24}/setup.py

@@ -19,8 +19,8 @@ setup(
         "pandas==2.1.4",
         "numpy==1.26.4",
         "datetime==5.5",
-        "scipy==1.15.3",
         "plotly==6.2.0",
+        "scipy==1.15.3"
     ],
     package_data={"steer_core.Data": ["database.db"]},
     scripts=[],

{steer_core-0.1.22 → steer_core-0.1.24}/steer_core/Apps/Utils/SliderControls.py

@@ -6,7 +6,7 @@ slider configurations based on parameter ranges.
 """
 
 import math
-from typing import List, Union, Dict
+from typing import List
 
 
 def calculate_slider_steps(

{steer_core-0.1.22 → steer_core-0.1.24}/steer_core/Constants/Units.py

@@ -34,6 +34,7 @@ Y_TO_S = 3600 * 24 * 365
 
 # Energy units
 W_TO_KW = 1e-3
+J_TO_WH = 1 / 3600
 
 # Angle units
 DEG_TO_RAD = 0.017453292519943295

{steer_core-0.1.22 → steer_core-0.1.24}/steer_core/Mixins/Coordinates.py

@@ -2,6 +2,8 @@ import numpy as np
 import pandas as pd
 from typing import Tuple
 
+from shapely import Polygon
+
 
 class CoordinateMixin:
     """
@@ -9,6 +11,94 @@ class CoordinateMixin:
     Provides methods for rotation, area calculation, and coordinate ordering.
     """
 
+    @staticmethod
+    def _calculate_segment_center_line(x_coords: np.ndarray, z_coords: np.ndarray) -> np.ndarray:
+        """
+        Calculate center line for a single segment of coordinates.
+        
+        Parameters
+        ----------
+        x_coords : np.ndarray
+            X coordinates for the segment
+        z_coords : np.ndarray
+            Z coordinates for the segment
+            
+        Returns
+        -------
+        np.ndarray
+            Array containing start and end points of the center line [[min_x, mean_z], [max_x, mean_z]]
+        """
+        min_x = np.nanmin(x_coords)
+        max_x = np.nanmax(x_coords)
+        min_z = np.nanmin(z_coords)
+        max_z = np.nanmax(z_coords)
+        mean_z = max_z - (max_z - min_z) / 2
+        
+        return np.array([[min_x, mean_z], [max_x, mean_z]])
+
+    @staticmethod
+    def get_xz_center_line(coordinates: np.ndarray) -> np.ndarray:
+        """
+        Generate center line(s) for coordinate data, handling both single and multi-segment polygons.
+        
+        Parameters
+        ----------
+        coordinates : np.ndarray
+            Array of 3D coordinates with shape (N, 3) where columns are [x, y, z].
+            NaN values in x or z coordinates indicate breaks between polygon segments.
+            
+        Returns
+        -------
+        np.ndarray
+            For single polygon: Array with shape (2, 2) containing start and end points.
+            For multiple segments: Array with center lines for each segment separated by [NaN, NaN].
+        """
+        x_coords = coordinates[:, 0]
+        z_coords = coordinates[:, 2]
+        
+        x_is_nan = np.isnan(x_coords)
+        
+        if np.any(x_is_nan):
+            # Handle multiple segments separated by NaN values
+            result_points = []
+            
+            # Find NaN indices to split the segments
+            nan_indices = np.where(x_is_nan)[0]
+            start_idx = 0
+            
+            # Process each segment
+            for nan_idx in nan_indices:
+                if nan_idx > start_idx:
+                    segment_x = x_coords[start_idx:nan_idx]
+                    segment_z = z_coords[start_idx:nan_idx]
+                    
+                    # Calculate center line for this segment if it has valid points
+                    if len(segment_x) > 0 and not np.all(np.isnan(segment_x)):
+                        segment_line = CoordinateMixin._calculate_segment_center_line(segment_x, segment_z)
+                        result_points.extend(segment_line.tolist())
+                        result_points.append([np.nan, np.nan])  # Add separator
+                
+                start_idx = nan_idx + 1
+            
+            # Handle the last segment if it exists
+            if start_idx < len(x_coords):
+                segment_x = x_coords[start_idx:]
+                segment_z = z_coords[start_idx:]
+                
+                if len(segment_x) > 0 and not np.all(np.isnan(segment_x)):
+                    segment_line = CoordinateMixin._calculate_segment_center_line(segment_x, segment_z)
+                    result_points.extend(segment_line.tolist())
+            
+            # Remove trailing NaN separator if it exists
+            if result_points and np.isnan(result_points[-1][0]):
+                result_points.pop()
+            
+            return np.array(result_points) if result_points else np.array([]).reshape(0, 2)
+        
+        else:
+            # Single polygon - use helper function
+            return CoordinateMixin._calculate_segment_center_line(x_coords, z_coords)
+
     @staticmethod
     def rotate_coordinates(
         coords: np.ndarray, axis: str, angle: float, center: tuple = None
@@ -241,7 +331,134 @@ class CoordinateMixin:
 
     @staticmethod
     def extrude_footprint(
-        x: np.ndarray, y: np.ndarray, datum: np.ndarray, thickness: float
+        x: np.ndarray, 
+        y: np.ndarray, 
+        datum: np.ndarray, 
+        thickness: float
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Extrude a 2D footprint to 3D, handling both single and multi-segment polygons.
+        
+        Parameters
+        ----------
+        x : np.ndarray
+            Array of x coordinates. NaN values indicate segment separators.
+        y : np.ndarray
+            Array of y coordinates. NaN values indicate segment separators.
+        datum : np.ndarray
+            Datum point for extrusion (shape (3,))
+        thickness : float
+            Thickness of the extrusion
+            
+        Returns
+        -------
+        Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]
+            Arrays of x, y, z coordinates and side labels, with NaN separators between segments
+        """
+        if not np.isnan(x).any() and not np.isnan(y).any():
+            return CoordinateMixin._extrude_single_footprint(x, y, datum, thickness)
+        
+        # Process segmented coordinates
+        segments = CoordinateMixin._extract_coordinate_segments(x, y)
+        extruded_sections = []
+        
+        for segment_x, segment_y in segments:
+            if len(segment_x) > 0 and not np.all(np.isnan(segment_x)):
+                result = CoordinateMixin._extrude_single_footprint(
+                    segment_x, segment_y, datum, thickness
+                )
+                extruded_sections.append(result)
+        
+        return CoordinateMixin._concatenate_with_separators(extruded_sections)
+
+    @staticmethod
+    def _extract_coordinate_segments(x: np.ndarray, y: np.ndarray, unify_xy: bool = False) -> list:
+        """
+        Extract coordinate segments separated by NaN values.
+        
+        Parameters
+        ----------
+        x : np.ndarray
+            X coordinates with NaN separators
+        y : np.ndarray
+            Y coordinates with NaN separators
+            
+        Returns
+        -------
+        list
+            List of (segment_x, segment_y) tuples
+        """
+        segments = []
+        x_is_nan = np.isnan(x)
+        nan_indices = np.where(x_is_nan)[0]
+        start_idx = 0
+        
+        # Process each segment between NaN values
+        for nan_idx in nan_indices:
+            if nan_idx > start_idx:
+                segments.append((x[start_idx:nan_idx], y[start_idx:nan_idx]))
+            start_idx = nan_idx + 1
+        
+        # Handle the last segment if it exists
+        if start_idx < len(x):
+            segments.append((x[start_idx:], y[start_idx:]))
+            
+        if unify_xy:
+            unified_segments = []
+            for i in range(len(segments)):
+                segment_x, segment_y = segments[i]
+                xy_array = np.column_stack((segment_x, segment_y))
+                unified_segments.append(xy_array)
+            return np.array(unified_segments)
+        else:
+            return segments
+
+    @staticmethod
+    def _concatenate_with_separators(sections: list) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Concatenate extruded sections with NaN separators.
+        
+        Parameters
+        ----------
+        sections : list
+            List of (x_ext, y_ext, z_ext, side_ext) tuples
+            
+        Returns
+        -------
+        Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]
+            Concatenated arrays with NaN separators
+        """
+        if not sections:
+            return np.array([]), np.array([]), np.array([]), np.array([])
+        
+        x_parts, y_parts, z_parts, side_parts = [], [], [], []
+        
+        for i, (x_ext, y_ext, z_ext, side_ext) in enumerate(sections):
+            x_parts.append(x_ext)
+            y_parts.append(y_ext)
+            z_parts.append(z_ext)
+            side_parts.append(side_ext)
+            
+            # Add NaN separators between segments (except for the last one)
+            if i < len(sections) - 1:
+                x_parts.append(np.array([np.nan]))
+                y_parts.append(np.array([np.nan]))
+                z_parts.append(np.array([np.nan]))
+                side_parts.append(np.array([None], dtype=object))
+        
+        return (
+            np.concatenate(x_parts),
+            np.concatenate(y_parts), 
+            np.concatenate(z_parts),
+            np.concatenate(side_parts)
+        )
+
+    @staticmethod
+    def _extrude_single_footprint(
+        x: np.ndarray, 
+        y: np.ndarray, 
+        datum: np.ndarray, 
+        thickness: float
     ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
         """
         Extrude the 2D footprint to 3D and label each point with its side ('a' or 'b'), with 'a' being the top side and 'b' the bottom side.
@@ -273,6 +490,102 @@ class CoordinateMixin:
 
         return x_full, y_full, z_full, side_full
 
+    @staticmethod
+    def get_coordinate_intersection(
+            coords1: np.ndarray,
+            coords2: np.ndarray
+    ) -> float:
+        """Calculate the intersection area between two sets of coordinates"""
+        polygon1 = Polygon(coords1)
+        polygon2 = Polygon(coords2)
+        intersection = polygon1.intersection(polygon2)
+        return intersection.area
+
+    @staticmethod
+    def insert_gaps_with_nans(
+        data: np.ndarray, 
+        column_index: int, 
+        tolerance_multiplier: float = 2.0
+    ) -> np.ndarray:
+        """
+        Insert rows of NaNs when gaps in a specified column exceed a tolerance threshold.
+        
+        Parameters
+        ----------
+        data : np.ndarray
+            Input array with shape (N, M) where N is number of rows and M is number of columns
+        column_index : int
+            Index of the column to analyze for gaps (0-based indexing)
+        tolerance_multiplier : float, optional
+            Multiplier for average gap to determine tolerance threshold, by default 2.0
+            
+        Returns
+        -------
+        np.ndarray
+            Array with NaN rows inserted where gaps exceed the tolerance
+            
+        Raises
+        ------
+        ValueError
+            If column_index is out of bounds for the array
+        IndexError
+            If data array is empty or has insufficient dimensions
+            
+        Examples
+        --------
+        >>> data = np.array([[1, 10], [2, 20], [5, 50], [6, 60]])
+        >>> result = CoordinateMixin.insert_gaps_with_nans(data, column_index=0)
+        >>> # Will insert NaN row between [2, 20] and [5, 50] if gap of 3 exceeds tolerance
+        """
+        if data.size == 0:
+            return data.copy()
+            
+        if len(data.shape) != 2:
+            raise ValueError("Input array must be 2-dimensional")
+            
+        if column_index < 0 or column_index >= data.shape[1]:
+            raise ValueError(f"column_index {column_index} is out of bounds for array with {data.shape[1]} columns")
+        
+        if data.shape[0] < 2:
+            return data.copy()
+        
+        # Extract the column values
+        column_values = data[:, column_index]
+        
+        # Remove NaN values for gap calculation
+        valid_values = column_values[~np.isnan(column_values)]
+        
+        if len(valid_values) < 2:
+            return data.copy()
+        
+        # Calculate gaps between consecutive values
+        gaps = np.diff(valid_values)
+        
+        # Calculate average gap and tolerance
+        average_gap = np.mean(np.abs(gaps))
+        tolerance = average_gap * tolerance_multiplier
+        
+        # Find positions where gaps exceed tolerance in original array
+        result_rows = []
+        
+        for i in range(len(data)):
+            result_rows.append(data[i])
+            
+            # Check if we should insert a gap after this row
+            if i < len(data) - 1:
+                current_val = column_values[i]
+                next_val = column_values[i + 1]
+                
+                # Only check gap if both values are not NaN
+                if not (np.isnan(current_val) or np.isnan(next_val)):
+                    gap = abs(next_val - current_val)
+                    if gap > tolerance:
+                        # Insert a row of NaNs
+                        nan_row = np.full(data.shape[1], np.nan)
+                        result_rows.append(nan_row)
+        
+        return np.array(result_rows)
+
     @staticmethod
     def remove_skip_coat_area(
         x_coords: np.ndarray,
@@ -359,3 +672,5 @@ class CoordinateMixin:
                 y_result.append(np.nan)
 
         return np.array(x_result, dtype=float), np.array(y_result, dtype=float)
+
+

steer_core-0.1.24/steer_core/Mixins/Data.py

@@ -0,0 +1,113 @@
+from copy import deepcopy
+import numpy as np
+from scipy.interpolate import PchipInterpolator
+
+
+class DataMixin:
+    """
+    A mixin class to handle data processing and validation for electrode materials.
+    Provides methods to calculate properties, check curve directions, and process half-cell curves.
+    """
+
+    @staticmethod
+    def enforce_monotonicity(array: np.ndarray) -> np.ndarray:
+        """
+        Enforces a monotonic version of the input array.
+        If the array is not monotonic, it is smoothed using cumulative max/min.
+        """
+        x = np.arange(len(array))
+        diff = np.diff(array)
+
+        if np.all(diff >= 0):
+            return array  # Already monotonic increasing
+
+        if np.all(diff <= 0):
+            return array  # Already monotonic decreasing, reverse it
+
+        # Determine general trend (ascending or descending)
+        ascending = array[-1] >= array[0]
+
+        # Sort by x so that PCHIP works (PCHIP requires increasing x)
+        # We'll smooth the array using PCHIP, then enforce monotonicity
+        interpolator = PchipInterpolator(x, array, extrapolate=False)
+        new_array = interpolator(x)
+
+        # Enforce strict monotonicity post-smoothing
+        if ascending:
+            new_array = np.maximum.accumulate(new_array)
+        else:
+            new_array = np.minimum.accumulate(new_array)
+
+        return new_array
+
+    @staticmethod
+    def sum_breakdowns(components, breakdown_type: str):
+        """
+        Aggregate breakdown dictionaries across multiple components.
+        If a component doesn't have the specified breakdown, use its fallback attribute instead.
+
+        Parameters
+        ----------
+        components : list
+            List of component objects
+        breakdown_type : str, optional
+            Type of breakdown to aggregate ('mass', 'cost', etc.), by default 'mass'
+            
+        Returns
+        -------
+        dict or float
+            Aggregated breakdown dictionary with summed values maintaining structure,
+            or simple float sum if no components have the specified breakdown
+        """
+        def add_dicts(dict1, dict2):
+            """Recursively add two dictionaries with matching structure."""
+            result = dict1.copy()
+            
+            for key, value in dict2.items():
+                if key in result:
+                    if isinstance(result[key], dict) and isinstance(value, dict):
+                        result[key] = add_dicts(result[key], value)
+                    elif isinstance(result[key], (int, float)) and isinstance(value, (int, float)):
+                        result[key] += value
+                else:
+                    result[key] = value
+            
+            return result
+        
+        breakdown_attr = f'_{breakdown_type}_breakdown'
+        fallback_attr = f'_{breakdown_type}'
+        
+        aggregated_breakdown = {}
+        simple_sum = 0
+        has_breakdown_components = False
+        
+        for component in components:
+            if hasattr(component, breakdown_attr):
+                breakdown_value = getattr(component, breakdown_attr)
+                if breakdown_value is not None:
+                    has_breakdown_components = True
+                    if not aggregated_breakdown:
+                        # Initialize with first component's breakdown
+                        aggregated_breakdown = deepcopy(breakdown_value)
+                    else:
+                        # Add subsequent breakdowns
+                        aggregated_breakdown = add_dicts(aggregated_breakdown, breakdown_value)
+            elif hasattr(component, fallback_attr):
+                # Component only has fallback attribute
+                fallback_value = getattr(component, fallback_attr)
+                if fallback_value is not None:
+                    simple_sum += fallback_value
+        
+        # If we have breakdown components, add the simple sum to the breakdown
+        if has_breakdown_components:
+            if simple_sum > 0:
+                total_key = f'total_{breakdown_type}'
+                if total_key in aggregated_breakdown:
+                    aggregated_breakdown[total_key] += simple_sum
+                else:
+                    aggregated_breakdown[total_key] = simple_sum
+            return aggregated_breakdown
+        else:
+            # No breakdown components, return simple sum
+            return simple_sum
+        

{steer_core-0.1.22 → steer_core-0.1.24}/steer_core/Mixins/Plotter.py

@@ -4,6 +4,48 @@ from typing import Dict, Any, Tuple, List, Union
 
 class PlotterMixin:
     
+    SCATTER_X_AXIS = dict(
+        showgrid=True,
+        gridcolor="rgba(128, 128, 128, 0.2)",
+        gridwidth=1,
+        zeroline=True,
+        zerolinecolor="rgba(0, 0, 0, 0.5)",
+        zerolinewidth=1,
+    )
+
+    SCATTER_Y_AXIS = dict(
+        showgrid=True,
+        gridcolor="rgba(128, 128, 128, 0.2)",
+        gridwidth=1,
+        zeroline=True,
+        zerolinecolor="rgba(0, 0, 0, 0.5)",
+        zerolinewidth=1,
+    )
+
+    SCHEMATIC_X_AXIS = dict(
+        zeroline=False,
+        scaleanchor="y",
+        title="X (mm)"
+    )
+
+    SCHEMATIC_Y_AXIS = dict(
+        zeroline=False,
+        title="Y (mm)"
+    )
+
+    SCHEMATIC_Z_AXIS = dict(
+        zeroline=False,
+        title="Z (mm)"
+    )
+
+    BOTTOM_LEGEND = dict(
+        orientation="h",
+        yanchor="top",
+        y=-0.3,
+        xanchor="center",
+        x=0.5,
+    )
+
     @staticmethod
     def plot_breakdown_sunburst(
         breakdown_dict: Dict[str, Any],
@@ -147,3 +189,6 @@ class PlotterMixin:
         )
 
         return fig
+
+
+    

{steer_core-0.1.22 → steer_core-0.1.24}/steer_core/Mixins/Serializer.py

@@ -41,3 +41,5 @@ class SerializerMixin:
         decoded = base64.b64decode(String.encode("utf-8"))
         obj = deepcopy(loads(decoded))
         return obj
+
+

{steer_core-0.1.22 → steer_core-0.1.24}/steer_core/Mixins/TypeChecker.py

@@ -1,4 +1,4 @@
-from typing import Type
+from typing import Type, Iterable
 import pandas as pd
 import numpy as np
 import plotly.graph_objects as go
@@ -33,26 +33,42 @@ class ValidationMixin:
         )
         
     @staticmethod
-    def validate_type(value: Type, expected_type: Type, name: str) -> None:
-        """
-        Validate that a value is of the expected type.
+    def validate_type(value, expected_type, name: str) -> None:
+        """Validate that a value is of the expected type or one of multiple allowed types.
 
         Parameters
         ----------
-        value : Type
+        value : Any
             The value to validate.
-        expected_type : Type
-            The expected type of the value.
+        expected_type : Type | Iterable[Type]
+            A single expected type or an iterable (list/tuple/set) of acceptable types.
         name : str
             The name of the parameter for error messages.
 
         Raises
         ------
         TypeError
-            If the value is not of the expected type.
+            If the value is not an instance of any of the expected types.
+
+        Examples
+        --------
+        >>> ValidationMixin.validate_type(5, int, 'count')            # OK
+        >>> ValidationMixin.validate_type(5, (int, float), 'count')   # OK
+        >>> ValidationMixin.validate_type('x', (int, float), 'count') # TypeError
+        >>> ValidationMixin.validate_type([1,2,3], list, 'items')     # OK
+        >>> ValidationMixin.validate_type([1,2,3], [list, tuple], 'items') # OK
         """
-        if not isinstance(value, expected_type):
-            raise TypeError(f"{name} must be of type {expected_type.__name__}. Provided: {type(value).__name__}.")
+        # Normalize expected types to a tuple for isinstance
+        if isinstance(expected_type, (list, set)):
+            expected_types = tuple(expected_type)
+        elif isinstance(expected_type, tuple):
+            expected_types = expected_type
+        else:
+            expected_types = (expected_type,)
+
+        if not isinstance(value, expected_types):
+            type_names = ', '.join(t.__name__ for t in expected_types)
+            raise TypeError(f"{name} must be of type {type_names}. Provided: {type(value).__name__}.")
 
     @staticmethod
     def validate_percentage(value: float, name: str) -> None:
@@ -195,6 +211,39 @@ class ValidationMixin:
         if not isinstance(value, (int, float)):
             raise ValueError(f"{name} must be a positive float. Provided: {value}.")
 
+    @staticmethod
+    def validate_positive_int(value: int, name: str) -> None:
+        """Validate that a value is a strictly positive integer.
+
+        Parameters
+        ----------
+        value : int
+            The value to validate.
+        name : str
+            The name of the parameter for error messages.
+
+        Raises
+        ------
+        TypeError
+            If the value is not an integer (bool is rejected even though it is a subclass of int).
+        ValueError
+            If the integer is not strictly positive (> 0).
+
+        Examples
+        --------
+        >>> ValidationMixin.validate_positive_int(5, 'count')        # OK
+        >>> ValidationMixin.validate_positive_int(0, 'count')        # ValueError
+        >>> ValidationMixin.validate_positive_int(-3, 'count')       # ValueError
+        >>> ValidationMixin.validate_positive_int(True, 'flag')      # TypeError (bool rejected)
+        >>> ValidationMixin.validate_positive_int(12_000, 'cycles')  # OK
+        """
+        # Reject bool explicitly (bool is subclass of int)
+        if isinstance(value, bool) or not isinstance(value, int):
+            raise TypeError(f"{name} must be a positive integer. Provided: {value} (type: {type(value).__name__}).")
+
+        if value <= 0:
+            raise ValueError(f"{name} must be a positive integer (> 0). Provided: {value}.")
+
     @staticmethod
     def validate_string(value: str, name: str) -> None:
         """

steer_core-0.1.24/steer_core/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.24"

{steer_core-0.1.22 → steer_core-0.1.24}/steer_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steer-core
-Version: 0.1.22
+Version: 0.1.24
 Summary: Modelling energy storage from cell to site - STEER OpenCell Design
 Home-page: https://github.com/nicholas9182/steer-core/
 Author: Nicholas Siemons
@@ -12,8 +12,8 @@ Requires-Python: >=3.10
 Requires-Dist: pandas==2.1.4
 Requires-Dist: numpy==1.26.4
 Requires-Dist: datetime==5.5
-Requires-Dist: scipy==1.15.3
 Requires-Dist: plotly==6.2.0
+Requires-Dist: scipy==1.15.3
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

steer_core-0.1.22/steer_core/Mixins/Data.py

@@ -1,40 +0,0 @@
-import numpy as np
-from scipy.interpolate import PchipInterpolator
-
-
-class DataMixin:
-    """
-    A mixin class to handle data processing and validation for electrode materials.
-    Provides methods to calculate properties, check curve directions, and process half-cell curves.
-    """
-
-    @staticmethod
-    def enforce_monotonicity(array: np.ndarray) -> np.ndarray:
-        """
-        Enforces a monotonic version of the input array.
-        If the array is not monotonic, it is smoothed using cumulative max/min.
-        """
-        x = np.arange(len(array))
-        diff = np.diff(array)
-
-        if np.all(diff >= 0):
-            return array  # Already monotonic increasing
-
-        if np.all(diff <= 0):
-            return array  # Already monotonic decreasing, reverse it
-
-        # Determine general trend (ascending or descending)
-        ascending = array[-1] >= array[0]
-
-        # Sort by x so that PCHIP works (PCHIP requires increasing x)
-        # We'll smooth the array using PCHIP, then enforce monotonicity
-        interpolator = PchipInterpolator(x, array, extrapolate=False)
-        new_array = interpolator(x)
-
-        # Enforce strict monotonicity post-smoothing
-        if ascending:
-            new_array = np.maximum.accumulate(new_array)
-        else:
-            new_array = np.minimum.accumulate(new_array)
-
-        return new_array

steer_core-0.1.22/steer_core/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.22"

{steer_core-0.1.22 → steer_core-0.1.24}/steer_core.egg-info/requires.txt

@@ -1,5 +1,5 @@
 pandas==2.1.4
 numpy==1.26.4
 datetime==5.5
-scipy==1.15.3
 plotly==6.2.0
+scipy==1.15.3