steer-core 0.1.23__tar.gz → 0.1.25__tar.gz

steer_core-0.1.25/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: steer-core
+Version: 0.1.25
+Summary: Modelling energy storage from cell to site - STEER OpenCell Design
+Author-email: Nicholas Siemons <nsiemons@stanford.edu>
+Maintainer-email: Nicholas Siemons <nsiemons@stanford.edu>
+License: MIT
+Project-URL: Homepage, https://github.com/nicholas9182/steer-core/
+Project-URL: Repository, https://github.com/nicholas9182/steer-core/
+Project-URL: Issues, https://github.com/nicholas9182/steer-core/issues
+Project-URL: Documentation, https://github.com/nicholas9182/steer-core/
+Keywords: energy,storage,battery,modeling,simulation
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pandas==2.1.4
+Requires-Dist: numpy==1.26.4
+Requires-Dist: datetime==5.5
+Requires-Dist: plotly==6.2.0
+Requires-Dist: scipy==1.15.3
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"

steer_core-0.1.25/pyproject.toml

@@ -0,0 +1,104 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "steer-core"
+dynamic = ["version"]
+description = "Modelling energy storage from cell to site - STEER OpenCell Design"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+    {name = "Nicholas Siemons", email = "nsiemons@stanford.edu"},
+]
+maintainers = [
+    {name = "Nicholas Siemons", email = "nsiemons@stanford.edu"},
+]
+keywords = ["energy", "storage", "battery", "modeling", "simulation"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+dependencies = [
+    "pandas==2.1.4",
+    "numpy==1.26.4",
+    "datetime==5.5",
+    "plotly==6.2.0",
+    "scipy==1.15.3",
+]
+
+[project.urls]
+Homepage = "https://github.com/nicholas9182/steer-core/"
+Repository = "https://github.com/nicholas9182/steer-core/"
+Issues = "https://github.com/nicholas9182/steer-core/issues"
+Documentation = "https://github.com/nicholas9182/steer-core/"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov",
+    "black",
+    "flake8",
+    "mypy",
+    "isort",
+]
+test = [
+    "pytest>=7.0",
+    "pytest-cov",
+]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["steer_core*"]
+
+[tool.setuptools.package-data]
+"steer_core.Data" = ["database.db"]
+
+[tool.setuptools.dynamic]
+version = {attr = "steer_core.__version__"}
+
+[tool.black]
+line-length = 88
+target-version = ['py310']
+include = '\.pyi?$'
+extend-exclude = '''
+/(
+  # directories
+  \.eggs
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | build
+  | dist
+)/
+'''
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+line_length = 88
+known_first_party = ["steer_core"]
+
+[tool.pytest.ini_options]
+minversion = "7.0"
+addopts = "-ra -q --strict-markers"
+testpaths = [
+    "tests",
+]
+python_files = [
+    "test_*.py",
+    "*_test.py",
+]

steer_core-0.1.25/steer_core/Apps/Callbacks/ConfigInteractions.py

@@ -0,0 +1,377 @@
+from typing import List, Tuple
+from dash import no_update
+
+
+def generate_parameters_and_ranges(object, config) -> Tuple[List[float], List[float], List[float]]:
+    """
+    Generate parameter value lists and their corresponding min/max ranges for any object.
+    
+    This function extracts parameter values from an object based on a configuration's
+    parameter list, and retrieves the minimum and maximum values for each parameter
+    if range attributes exist (e.g., '{param}_range'), otherwise uses the current
+    value as both min and max.
+    
+    Parameters
+    ----------
+    object : Any
+        The object from which to extract parameter values. Must have attributes
+        corresponding to the parameters listed in config.parameter_list.
+    config : Type
+        Configuration class or object that contains a 'parameter_list' attribute
+        specifying which parameters to extract from the object.
+    
+    Returns
+    -------
+    Tuple[List[float], List[float], List[float]]
+        A tuple containing three lists:
+        - parameter_values: Current values of each parameter
+        - min_values: Minimum values for each parameter (from {param}_range[0] 
+          or current value if no range exists)
+        - max_values: Maximum values for each parameter (from {param}_range[1] 
+          or current value if no range exists)
+    
+    Examples
+    --------
+    >>> class MyObject:
+    ...     def __init__(self):
+    ...         self.temperature = 25.0
+    ...         self.temperature_range = (0.0, 100.0)
+    ...         self.pressure = 1.0
+    >>> 
+    >>> class Config:
+    ...     parameter_list = ['temperature', 'pressure']
+    >>> 
+    >>> obj = MyObject()
+    >>> values, mins, maxs = generate_parameter_and_list_ranges(obj, Config)
+    >>> print(values)  # [25.0, 1.0]
+    >>> print(mins)    # [0.0, 1.0]
+    >>> print(maxs)    # [100.0, 1.0]
+    
+    Notes
+    -----
+    - If an object has a '{param}_range' attribute, it should be a tuple/list
+      with exactly two elements: (min_value, max_value)
+    - If no range attribute exists for a parameter, the current value is used
+      for both minimum and maximum values
+    - All extracted values are expected to be numeric (convertible to float)
+    """
+    parameter_values = []
+    min_values = []
+    max_values = []
+
+    parameter_list = config.parameter_list
+
+    for param in parameter_list:
+
+        value = getattr(object, param)
+        parameter_values.append(value)
+
+        if hasattr(object, f"{param}_range"):
+            min_values.append(getattr(object, f"{param}_range")[0])
+            max_values.append(getattr(object, f"{param}_range")[1])
+        else:
+            min_values.append(value)
+            max_values.append(value)
+
+    return parameter_values, min_values, max_values
+
+
+
+def generate_rangeslider_parameters_and_ranges(object, config) -> Tuple[
+    List[float],
+    List[float],
+    List[float],
+    List[float],
+]:
+    """
+    Generate range slider parameter values and their corresponding min/max bounds for any object.
+    
+    This function extracts range parameter values from an object based on a configuration's
+    range_slider_parameters list. Each parameter is expected to be a tuple/list representing 
+    a range (start, end). It also retrieves the absolute minimum and maximum bounds for each 
+    parameter from corresponding '{param}_range' attributes, or uses the current range values
+    as bounds if no range attribute exists.
+    
+    Parameters
+    ----------
+    object : Any
+        The object from which to extract range parameter values. Must have attributes
+        corresponding to the parameters listed in config.range_slider_parameters, where 
+        each attribute contains a tuple/list of (start, end) values. Optionally has 
+        '{param}_range' attributes defining the absolute bounds for each parameter.
+    config : Any
+        Configuration class or object that contains a 'range_slider_parameters' attribute
+        specifying which range parameters to extract from the object.
+    
+    Returns
+    -------
+    Tuple[List[float], List[float], List[float], List[float]]
+        A tuple containing four lists:
+        - start_values: Start values for each range parameter (from param[0])
+        - end_values: End values for each range parameter (from param[1])
+        - min_values: Absolute minimum bounds for each parameter (from {param}_range[0] 
+          or param[0] if no range exists)
+        - max_values: Absolute maximum bounds for each parameter (from {param}_range[1] 
+          or param[1] if no range exists)
+    
+    Examples
+    --------
+    >>> class MyCollector:
+    ...     def __init__(self):
+    ...         self.voltage_window = (2.5, 4.2)  # Current range setting
+    ...         self.voltage_window_range = (0.0, 5.0)  # Absolute bounds
+    ...         self.current_limit = (0.1, 2.0)  # Current range setting
+    ...         # No current_limit_range, so uses current values as bounds
+    >>> 
+    >>> class Config:
+    ...     range_slider_parameters = ['voltage_window', 'current_limit']
+    >>> 
+    >>> collector = MyCollector()
+    >>> starts, ends, mins, maxs = generate_rangeslider_parameters_and_ranges_from_config(
+    ...     collector, Config)
+    >>> print(starts)  # [2.5, 0.1]
+    >>> print(ends)    # [4.2, 2.0]
+    >>> print(mins)    # [0.0, 0.1]  # Uses range for voltage, current value for current
+    >>> print(maxs)    # [5.0, 2.0]  # Uses range for voltage, current value for current
+    
+    Notes
+    -----
+    - If config.range_slider_parameters is empty, returns four empty lists
+    - Each parameter in range_slider_parameters must exist as an attribute on the object
+      and contain exactly two elements: (start_value, end_value)
+    - If a parameter has a corresponding '{param}_range' attribute, those bounds are used
+    - If no range attribute exists for a parameter, the current start/end values are used
+      as the minimum/maximum bounds respectively
+    - All values are expected to be numeric (convertible to float)
+    - This function is typically used for range slider UI components where
+      users can select a range within predefined bounds
+    
+    Raises
+    ------    
+    AttributeError
+        If the object doesn't have the required parameter attributes or if config
+        doesn't have range_slider_parameters attribute
+    IndexError
+        If parameter values don't contain exactly two elements
+    """
+    start_values = []
+    end_values = []
+    min_values = []
+    max_values = []
+
+    parameter_list = config.range_slider_parameters
+
+    for param in parameter_list:
+        
+        value = getattr(object, param)
+        start_values.append(value[0])
+        end_values.append(value[1])
+
+        if hasattr(object, f"{param}_range"):
+            min_values.append(getattr(object, f"{param}_range")[0])
+            max_values.append(getattr(object, f"{param}_range")[1])
+        else:
+            min_values.append(value[0])
+            max_values.append(value[1])
+
+    return start_values, end_values, min_values, max_values
+
+
+def validate_dependent_properties(object, config) -> None:
+    """
+    Validate and clamp dependent properties to their valid hard ranges for any object.
+    
+    This function validates parameter values from an object based on a configuration's
+    parameter list, checking each parameter against its corresponding '{param}_hard_range'
+    attribute. If a parameter value falls outside its hard range, it is automatically
+    clamped to the nearest valid boundary (minimum or maximum).
+    
+    Parameters
+    ----------
+    object : Any
+        The object whose parameter values will be validated and potentially modified.
+        Must have attributes corresponding to the parameters listed in config.parameter_list.
+        Should have '{param}_hard_range' attributes defining the valid bounds for validation.
+    config : Any
+        Configuration class or object that contains a 'parameter_list' attribute
+        specifying which parameters to validate on the object.
+    
+    Returns
+    -------
+    None
+        This function modifies the object in-place and does not return any values.
+        
+    Examples
+    --------
+    >>> class MyObject:
+    ...     def __init__(self):
+    ...         self.temperature = 150.0  # Outside valid range
+    ...         self.temperature_hard_range = (0.0, 100.0)
+    ...         self.pressure = 0.5  # Within valid range
+    ...         self.pressure_hard_range = (0.0, 10.0)
+    >>> 
+    >>> class Config:
+    ...     parameter_list = ['temperature', 'pressure']
+    >>> 
+    >>> obj = MyObject()
+    >>> print(obj.temperature)  # 150.0 (before validation)
+    >>> validate_dependent_properties(obj, Config)
+    >>> print(obj.temperature)  # 100.0 (clamped to maximum)
+    >>> print(obj.pressure)     # 0.5 (unchanged, within range)
+    
+    Notes
+    -----
+    - Only parameters with corresponding '{param}_hard_range' attributes are validated
+    - Parameters without hard range attributes are silently skipped (no validation performed)
+    - Hard range attributes should be tuples/lists with exactly two elements: (min_value, max_value)
+    - Values are clamped to the nearest boundary if they fall outside the valid range
+    - This function modifies the object in-place, changing parameter values as needed
+    - Typically used after parameter updates to ensure all values remain within valid bounds
+    
+    Raises
+    ------
+    AttributeError
+        If the object doesn't have a parameter attribute listed in config.parameter_list,
+        or if config doesn't have a parameter_list attribute
+    IndexError
+        If a hard_range attribute doesn't contain exactly two elements
+    """
+    parameter_list = config.parameter_list
+    
+    for param in parameter_list:
+        try:
+            # Get the hard range and current value for this parameter
+            param_range = getattr(object, f"{param}_hard_range")
+            param_value = getattr(object, param)
+            
+            # Clamp value to valid range if necessary
+            if param_value < param_range[0]:
+                setattr(object, param, param_range[0])
+            elif param_value > param_range[1]:
+                setattr(object, param, param_range[1])
+                
+        except AttributeError:
+            # Parameter or hard range doesn't exist, skip validation
+            continue
+
+
+def create_no_update_response(
+    config=None,
+    existing_warnings: List[str] = [],
+    n: int = None,
+    n_rangeslider: int = None,
+) -> Tuple:
+    """
+    Create a no-update response tuple for Dash callbacks based on configuration parameters.
+    
+    This function generates a standardized response tuple containing `no_update` values
+    for all UI components defined in a configuration object. This is typically used in
+    Dash callbacks when no updates should be made to the UI components, preserving
+    their current state while potentially updating warning messages.
+    
+    Parameters
+    ----------
+    config : Any, optional
+        Configuration object that defines the UI components and their parameters.
+        Should contain attributes like 'parameter_list', 'range_slider_parameters',
+        'dropdown_menu', 'radioitem_parameters', and 'text_parameters'.
+        If None, only basic response structure is created.
+    existing_warnings : List[str], default []
+        List of existing warning messages to include in the response.
+        These warnings will be preserved in the callback output.
+    n : int, optional
+        Number of regular slider/input parameters. If None, determined from
+        config.parameter_list length. Used to create the correct number of
+        no_update responses for sliders and inputs.
+    n_rangeslider : int, optional
+        Number of range slider parameters. If None, determined from
+        config.range_slider_parameters length. Used to create the correct
+        number of no_update responses for range sliders.
+    
+    Returns
+    -------
+    Tuple
+        A tuple containing warning messages followed by no_update responses for all
+        UI components defined in the configuration:
+        - warnings: List[str] - Warning messages (first element)
+        - cache_key: no_update - Cache key for callback optimization
+        - slider_values: List[no_update] - Current slider values
+        - slider_mins: List[no_update] - Slider minimum values
+        - slider_maxs: List[no_update] - Slider maximum values
+        - slider_marks: List[no_update] - Slider tick marks
+        - slider_steps: List[no_update] - Slider step sizes
+        - input_steps: List[no_update] - Input field step sizes
+        
+        Additional elements based on config attributes:
+        - dropdown_value: no_update (if config.dropdown_menu exists)
+        - range_slider_*: List[no_update] (if config.range_slider_parameters exists)
+        - radioitem_values: List[no_update] (if config.radioitem_parameters exists)
+        - text_values: List[no_update] (if config.text_parameters exists)
+    
+    Examples
+    --------
+    >>> class Config:
+    ...     parameter_list = ['temperature', 'pressure']
+    ...     dropdown_menu = True
+    ...     range_slider_parameters = ['voltage_window']
+    ...     radioitem_parameters = ['mode']
+    ...     text_parameters = ['label']
+    >>> 
+    >>> config = Config()
+    >>> warnings = ['Temperature out of range']
+    >>> response = create_no_update_response(config, warnings)
+    >>> print(len(response))  # Number of response elements
+    >>> print(response[0])    # ['Temperature out of range']
+    >>> print(response[1])    # no_update (cache_key)
+    
+    Notes
+    -----
+    - This function is primarily used in Dash callback error handling or when
+      callback conditions are not met and no UI updates should occur
+    - The response tuple structure must match the callback's Output specification
+    - Optional UI components (dropdown, range sliders, radio items, text inputs)
+      are only included in the response if they exist in the configuration
+    - All UI component responses use Dash's `no_update` to preserve current state
+    - The function automatically determines response tuple length based on config
+    
+    Raises
+    ------
+    AttributeError
+        If config object doesn't have expected attributes when accessed
+    """
+    n = len(config.parameter_list) if n is None else n
+
+    response = (
+        no_update,  # cache_key
+        [no_update] * n,  # slider values
+        [no_update] * n,  # slider mins
+        [no_update] * n,  # slider maxs
+        [no_update] * n,  # slider marks
+        [no_update] * n,  # slider steps
+        [no_update] * n,  # input steps
+    )
+
+    if hasattr(config, "dropdown_menu") and config.dropdown_menu:
+        response += (no_update,)
+
+    if hasattr(config, "range_slider_parameters") and config.range_slider_parameters:
+        n_rangeslider = len(config.range_slider_parameters) if n_rangeslider is None else n_rangeslider
+        response += (
+            [no_update] * n_rangeslider,  # range_slider_values
+            [no_update] * n_rangeslider,  # range slider mins
+            [no_update] * n_rangeslider,  # range slider maxs
+            [no_update] * n_rangeslider,  # range slider marks
+            [no_update] * n_rangeslider,  # range slider steps
+            [no_update] * n_rangeslider,  # range slider start values
+            [no_update] * n_rangeslider,  # range slider end values
+        )
+
+    if hasattr(config, "radioitem_parameters") and config.radioitem_parameters:
+        num_radioitem_params = len(config.radioitem_parameters)
+        response += ([no_update] * num_radioitem_params,)  # radioitem values
+
+    if hasattr(config, "text_parameters") and config.text_parameters:
+        num_text_params = len(config.text_parameters)
+        response += ([no_update] * num_text_params,)  # text item values
+
+    return (existing_warnings,) + tuple(response)

steer_core-0.1.25/steer_core/Apps/Callbacks/StyleManagement.py

@@ -0,0 +1,60 @@
+from dash import no_update
+from typing import List
+
+def update_style_display(current_style, target_display):
+    """
+    Helper function to update style display property with safe None handling.
+    
+    Args:
+        current_style: Current style dict or None
+        target_display: Target display value ("block" or "none")
+        
+    Returns:
+        no_update if style already has target display, otherwise updated style dict
+    """
+    current_display = (current_style or {}).get("display")
+    if current_display == target_display:
+        return no_update
+    return {**(current_style or {}), "display": target_display}
+
+
+
+def update_tab_styles(active_tab: str, tab_names: List[str], current_styles: List[dict]) -> List:
+    """
+    Helper function to update tab styles based on the active tab.
+    Only updates styles when the display property needs to change.
+    
+    Parameters
+    ----------
+    active_tab : str
+        The currently active tab name
+    tab_names : List[str]
+        List of all tab names to check against
+    current_styles : List[dict]
+        List of current style dictionaries for each tab
+        
+    Returns
+    -------
+    List
+        List of updated styles or no_update for each tab
+    """
+    updated_styles = []
+    
+    for tab_name, current_style in zip(tab_names, current_styles):
+        # Determine what the display should be
+        should_display = "block" if active_tab == tab_name else "none"
+        
+        # Get current display value (handle None style case)
+        current_display = (current_style or {}).get("display")
+        
+        # If display is already correct, return no_update
+        if current_display == should_display:
+            updated_styles.append(no_update)
+        else:
+            # Create new style preserving existing properties
+            new_style = {**(current_style or {}), "display": should_display}
+            updated_styles.append(new_style)
+    
+    return updated_styles
+
+

{steer_core-0.1.23 → steer_core-0.1.25}/steer_core/DataManager.py

@@ -259,6 +259,26 @@ class DataManager:
         )
 
         return data
+    
+    def get_tape_materials(self, most_recent: bool = True) -> pd.DataFrame:
+        """
+        Retrieves tape materials from the database.
+
+        :param most_recent: If True, returns only the most recent entry.
+        :return: DataFrame with tape materials.
+        """
+        data = (
+            self.get_data(table_name="tape_materials")
+            .groupby("name", group_keys=False)
+            .apply(
+                lambda x: x.sort_values("date", ascending=False).head(1)
+                if most_recent
+                else x
+            )
+            .reset_index(drop=True)
+        )
+
+        return data
 
     @staticmethod
     def read_half_cell_curve(half_cell_path) -> pd.DataFrame:

{steer_core-0.1.23 → steer_core-0.1.25}/steer_core/Mixins/Coordinates.py

@@ -2,7 +2,7 @@ import numpy as np
 import pandas as pd
 from typing import Tuple
 
-from shapely import Polygon
+from shapely import Polygon, minimum_bounding_circle, Point
 
 
 class CoordinateMixin:
@@ -10,6 +10,31 @@ class CoordinateMixin:
     A class to manage and manipulate 3D coordinates.
     Provides methods for rotation, area calculation, and coordinate ordering.
     """
+    @staticmethod
+    def get_radius_of_points(coords: np.ndarray) -> float:
+        """Calculate the radius of a spiral given its coordinates.
+
+        Parameters
+        ----------
+        coords : np.ndarray
+            Array of shape (N, 2) with columns [x, z]
+
+        Returns
+        -------
+        float
+            Radius of the spiral in meters
+
+        Raises
+        ------
+        ValueError
+            If input coordinates are invalid
+        """
+        polygon = Polygon(coords)
+        circle = minimum_bounding_circle(polygon)
+        center = circle.centroid
+        first_point = list(circle.exterior.coords)[0]
+        radius = Point(center).distance(Point(first_point))
+        return radius, (center.x, center.y)
 
     @staticmethod
     def _calculate_segment_center_line(x_coords: np.ndarray, z_coords: np.ndarray) -> np.ndarray:
@@ -52,7 +77,11 @@ class CoordinateMixin:
         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].
+            For empty coordinates: Empty array with shape (0, 2).
         """
+        if coordinates.size == 0:
+            return np.array([]).reshape(0, 2)
+            
         x_coords = coordinates[:, 0]
         z_coords = coordinates[:, 2]
         
@@ -218,6 +247,7 @@ class CoordinateMixin:
 
     @staticmethod
     def order_coordinates_clockwise(df: pd.DataFrame, plane="xy") -> pd.DataFrame:
+
         axis_1 = plane[0]
         axis_2 = plane[1]
 
@@ -227,12 +257,230 @@ class CoordinateMixin:
         angles = np.arctan2(df[axis_2] - cy, df[axis_1] - cx)
 
         df["angle"] = angles
+
         df_sorted = (
             df.sort_values(by="angle").drop(columns="angle").reset_index(drop=True)
         )
 
         return df_sorted
 
+    @staticmethod
+    def order_coordinates_clockwise_numpy(
+        coords: np.ndarray, 
+        plane: str = "xy"
+    ) -> np.ndarray:
+        """
+        Order 3D coordinates in clockwise direction based on a specified plane.
+        Handles multiple coordinate blocks separated by NaN rows.
+        
+        Parameters
+        ----------
+        coords : np.ndarray
+            Array of 3D coordinates with shape (N, 3) where columns are [x, y, z].
+            NaN rows indicate separations between coordinate blocks.
+        plane : str, optional
+            Plane to use for ordering ('xy', 'xz', 'yz'), by default 'xy'
+            
+        Returns
+        -------
+        np.ndarray
+            Sorted coordinates array with same shape as input, with each block
+            sorted clockwise and separated by NaN rows
+            
+        Raises
+        ------
+        ValueError
+            If coords array doesn't have shape (N, 3) or plane is invalid
+        """
+        if len(coords.shape) != 2 or coords.shape[1] != 3:
+            raise ValueError("coords must be a 2D array with 3 columns (x, y, z)")
+        
+        if coords.shape[0] < 2:
+            return coords.copy()
+        
+        # Map plane string to column indices
+        plane_mapping = {
+            'xy': (0, 1),  # x, y columns
+            'xz': (0, 2),  # x, z columns  
+            'yz': (1, 2)   # y, z columns
+        }
+        
+        if plane not in plane_mapping:
+            raise ValueError(f"plane must be one of {list(plane_mapping.keys())}, got '{plane}'")
+        
+        # Check if we have NaN rows (multiple coordinate blocks)
+        x_coords = coords[:, 0]
+        x_is_nan = np.isnan(x_coords)
+        
+        if not np.any(x_is_nan):
+            # Single block - use original logic
+            return CoordinateMixin._sort_single_coordinate_block(coords, plane)
+        
+        # Multiple blocks - extract and sort each block
+        segments = CoordinateMixin._extract_coordinate_blocks(coords)
+        sorted_blocks = []
+        
+        for block in segments:
+            if len(block) > 1:  # Only sort if block has more than 1 coordinate
+                sorted_block = CoordinateMixin._sort_single_coordinate_block(block, plane)
+                sorted_blocks.append(sorted_block)
+            elif len(block) == 1:  # Single coordinate, keep as is
+                sorted_blocks.append(block)
+        
+        return CoordinateMixin._concatenate_coordinate_blocks_with_nans(sorted_blocks)
+
+    @staticmethod
+    def concat_with_nan_separators(arrays: list) -> np.ndarray:
+        """
+        Efficiently concatenate numpy arrays with NaN separators.
+        
+        Parameters
+        ----------
+        arrays : list
+            List of numpy arrays to concatenate
+            
+        Returns
+        -------
+        np.ndarray
+            Concatenated array with NaN separators
+        """
+        if not arrays:
+            return np.array([])
+            
+        if len(arrays) == 1:
+            return arrays[0]
+        
+        # Calculate total size needed
+        total_rows = sum(arr.shape[0] for arr in arrays) + len(arrays) - 1
+        n_cols = arrays[0].shape[1]
+        
+        # Pre-allocate result array
+        result = np.empty((total_rows, n_cols))
+        
+        current_row = 0
+        for i, arr in enumerate(arrays):
+            # Copy array data
+            result[current_row:current_row + arr.shape[0]] = arr
+            current_row += arr.shape[0]
+            
+            # Add NaN separator (except after last array)
+            if i < len(arrays) - 1:
+                result[current_row] = np.nan
+                current_row += 1
+        
+        return result
+
+    @staticmethod
+    def _sort_single_coordinate_block(
+        coords: np.ndarray, 
+        plane: str
+    ) -> np.ndarray:
+        """
+        Sort a single coordinate block clockwise.
+        
+        Parameters
+        ----------
+        coords : np.ndarray
+            Array of 3D coordinates with shape (N, 3)
+        plane : str
+            Plane to use for ordering ('xy', 'xz', 'yz')
+            
+        Returns
+        -------
+        np.ndarray
+            Sorted coordinates array
+        """
+        plane_mapping = {
+            'xy': (0, 1),  # x, y columns
+            'xz': (0, 2),  # x, z columns  
+            'yz': (1, 2)   # y, z columns
+        }
+        
+        axis_1_idx, axis_2_idx = plane_mapping[plane]
+        
+        # Extract the relevant coordinates for the specified plane
+        axis_1_coords = coords[:, axis_1_idx]
+        axis_2_coords = coords[:, axis_2_idx]
+        
+        # Calculate center point
+        cx = np.nanmean(axis_1_coords)
+        cy = np.nanmean(axis_2_coords)
+        
+        # Calculate angles from center to each point
+        angles = np.arctan2(axis_2_coords - cy, axis_1_coords - cx)
+        
+        # Sort by angle to get clockwise ordering
+        sorted_indices = np.argsort(angles)
+        
+        return coords[sorted_indices]
+
+    @staticmethod
+    def _extract_coordinate_blocks(coords: np.ndarray) -> list:
+        """
+        Extract coordinate blocks separated by NaN rows.
+        
+        Parameters
+        ----------
+        coords : np.ndarray
+            Array of 3D coordinates with NaN row separators
+            
+        Returns
+        -------
+        list
+            List of coordinate block arrays
+        """
+        blocks = []
+        x_coords = coords[:, 0]
+        x_is_nan = np.isnan(x_coords)
+        nan_indices = np.where(x_is_nan)[0]
+        start_idx = 0
+        
+        # Process each block between NaN rows
+        for nan_idx in nan_indices:
+            if nan_idx > start_idx:
+                block = coords[start_idx:nan_idx]
+                if len(block) > 0:
+                    blocks.append(block)
+            start_idx = nan_idx + 1
+        
+        # Handle the last block if it exists
+        if start_idx < len(coords):
+            block = coords[start_idx:]
+            if len(block) > 0:
+                blocks.append(block)
+            
+        return blocks
+
+    @staticmethod
+    def _concatenate_coordinate_blocks_with_nans(blocks: list) -> np.ndarray:
+        """
+        Concatenate coordinate blocks with NaN row separators.
+        
+        Parameters
+        ----------
+        blocks : list
+            List of coordinate block arrays
+            
+        Returns
+        -------
+        np.ndarray
+            Concatenated array with NaN separators
+        """
+        if not blocks:
+            return np.array([]).reshape(0, 3)
+        
+        result_parts = []
+        
+        for i, block in enumerate(blocks):
+            result_parts.append(block)
+            
+            # Add NaN separator between blocks (except for the last one)
+            if i < len(blocks) - 1:
+                nan_row = np.full((1, 3), np.nan)
+                result_parts.append(nan_row)
+        
+        return np.vstack(result_parts)
+
     @staticmethod
     def _rotate_valid_coordinates(
         coords: np.ndarray, axis: str, angle: float
@@ -261,9 +509,7 @@ class CoordinateMixin:
         Calculate the area of a single closed shape using the shoelace formula.
         """
         if len(x) < 3 or len(y) < 3:
-            raise ValueError(
-                "Trace must contain at least 3 points to form a closed shape."
-            )
+            return 0.0
 
         # Convert to float arrays to avoid object dtype issues
         x = np.asarray(x, dtype=float)

{steer_core-0.1.23 → steer_core-0.1.25}/steer_core/Mixins/Plotter.py

@@ -1,5 +1,6 @@
 import plotly.graph_objects as go
 from typing import Dict, Any, Tuple, List, Union
+from steer_core.Mixins.Coordinates import CoordinateMixin
 
 
 class PlotterMixin:
@@ -46,6 +47,86 @@ class PlotterMixin:
         x=0.5,
     )
 
+    @staticmethod
+    def create_component_trace(
+            components, 
+            coord_attr, 
+            name, 
+            line_width, 
+            color_func, 
+            unit_conversion_factor,
+            order_clockwise: str = None
+            ):
+        """
+        Create a single trace for a component or group of components with NaN separators.
+        
+        Parameters
+        ----------
+        components : list or object
+            Single component or list of components to process
+        coord_attr : str
+            Attribute path for coordinates (e.g., '_a_side_coating_coordinates')
+        name : str
+            Name for the trace
+        line_width : float
+            Width of the trace line
+        color_func : callable
+            Function to get color from component
+        unit_conversion_factor : float
+            Factor to convert coordinates to desired units
+        order_clockwise : str or None, optional
+            Plane for clockwise ordering ('xy', 'xz', 'yz') or None to disable, by default None
+            
+        Returns
+        -------
+        go.Scatter or None
+            Plotly scatter trace or None if no valid coordinates
+        """
+        # Convert single component to list for uniform processing
+        if not isinstance(components, list):
+            components = [components]
+            
+        if not components:
+            return None
+            
+        # Extract coordinates using nested getattr for dot notation
+        coord_arrays = []
+        for component in components:
+            coords = component
+            # Handle nested attributes like '_current_collector._body_coordinates'
+            for attr_part in coord_attr.split('.'):
+                coords = getattr(coords, attr_part)
+                
+            if coords is not None and len(coords) > 0:
+                coord_arrays.append(coords)
+
+        if not coord_arrays:
+            return None
+        
+        # Concatenate coordinates with NaN separators
+        combined_coords = CoordinateMixin.concat_with_nan_separators(coord_arrays)
+        
+        # Order coordinates clockwise if requested
+        if order_clockwise is not None:
+            combined_coords = CoordinateMixin.order_coordinates_clockwise_numpy(combined_coords, plane=order_clockwise)
+        
+        # Convert to mm and extract y,z coordinates directly (avoid DataFrame overhead)
+        y_coords = combined_coords[:, 1] * unit_conversion_factor
+        z_coords = combined_coords[:, 2] * unit_conversion_factor
+        
+        # Create trace
+        return go.Scatter(
+            x=y_coords,
+            y=z_coords,
+            mode="lines",
+            name=name,
+            line={'width': line_width, 'color': "black"},
+            fill="toself",
+            fillcolor=color_func(components[0]),
+            legendgroup=name,
+            showlegend=True,
+        )
+
     @staticmethod
     def plot_breakdown_sunburst(
         breakdown_dict: Dict[str, Any],

steer_core-0.1.25/steer_core/__init__.py

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

steer_core-0.1.25/steer_core.egg-info/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: steer-core
+Version: 0.1.25
+Summary: Modelling energy storage from cell to site - STEER OpenCell Design
+Author-email: Nicholas Siemons <nsiemons@stanford.edu>
+Maintainer-email: Nicholas Siemons <nsiemons@stanford.edu>
+License: MIT
+Project-URL: Homepage, https://github.com/nicholas9182/steer-core/
+Project-URL: Repository, https://github.com/nicholas9182/steer-core/
+Project-URL: Issues, https://github.com/nicholas9182/steer-core/issues
+Project-URL: Documentation, https://github.com/nicholas9182/steer-core/
+Keywords: energy,storage,battery,modeling,simulation
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pandas==2.1.4
+Requires-Dist: numpy==1.26.4
+Requires-Dist: datetime==5.5
+Requires-Dist: plotly==6.2.0
+Requires-Dist: scipy==1.15.3
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"

{steer_core-0.1.23 → steer_core-0.1.25}/steer_core.egg-info/SOURCES.txt

@@ -1,5 +1,5 @@
 README.md
-setup.py
+pyproject.toml
 steer_core/DataManager.py
 steer_core/__init__.py
 steer_core.egg-info/PKG-INFO
@@ -9,6 +9,8 @@ steer_core.egg-info/requires.txt
 steer_core.egg-info/top_level.txt
 steer_core/Apps/ContextManagers.py
 steer_core/Apps/__init__.py
+steer_core/Apps/Callbacks/ConfigInteractions.py
+steer_core/Apps/Callbacks/StyleManagement.py
 steer_core/Apps/Components/MaterialSelectors.py
 steer_core/Apps/Components/RangeSliderComponents.py
 steer_core/Apps/Components/SliderComponents.py

steer_core-0.1.25/steer_core.egg-info/requires.txt

@@ -0,0 +1,17 @@
+pandas==2.1.4
+numpy==1.26.4
+datetime==5.5
+plotly==6.2.0
+scipy==1.15.3
+
+[dev]
+pytest>=7.0
+pytest-cov
+black
+flake8
+mypy
+isort
+
+[test]
+pytest>=7.0
+pytest-cov

steer_core-0.1.23/PKG-INFO

@@ -1,24 +0,0 @@
-Metadata-Version: 2.4
-Name: steer-core
-Version: 0.1.23
-Summary: Modelling energy storage from cell to site - STEER OpenCell Design
-Home-page: https://github.com/nicholas9182/steer-core/
-Author: Nicholas Siemons
-Author-email: nsiemons@stanford.edu
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-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: dash==2.18.1
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary

steer_core-0.1.23/setup.py

@@ -1,34 +0,0 @@
-from setuptools import setup, find_packages
-import pathlib
-import re
-
-root = pathlib.Path(__file__).parent
-init = root / "steer_core" / "__init__.py"
-version = re.search(r'__version__\s*=\s*"([^"]+)"', init.read_text()).group(1)
-
-setup(
-    name="steer-core",
-    version=version,
-    description="Modelling energy storage from cell to site - STEER OpenCell Design",
-    author="Nicholas Siemons",
-    author_email="nsiemons@stanford.edu",
-    url="https://github.com/nicholas9182/steer-core/",
-    packages=find_packages(),
-    include_package_data=True,
-    install_requires=[
-        "pandas==2.1.4",
-        "numpy==1.26.4",
-        "datetime==5.5",
-        "scipy==1.15.3",
-        "plotly==6.2.0",
-        "dash==2.18.1",
-    ],
-    package_data={"steer_core.Data": ["database.db"]},
-    scripts=[],
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-    ],
-    python_requires=">=3.10",
-)

steer_core-0.1.23/steer_core/__init__.py

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

steer_core-0.1.23/steer_core.egg-info/PKG-INFO

@@ -1,24 +0,0 @@
-Metadata-Version: 2.4
-Name: steer-core
-Version: 0.1.23
-Summary: Modelling energy storage from cell to site - STEER OpenCell Design
-Home-page: https://github.com/nicholas9182/steer-core/
-Author: Nicholas Siemons
-Author-email: nsiemons@stanford.edu
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-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: dash==2.18.1
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary

steer_core-0.1.23/steer_core.egg-info/requires.txt

@@ -1,6 +0,0 @@
-pandas==2.1.4
-numpy==1.26.4
-datetime==5.5
-scipy==1.15.3
-plotly==6.2.0
-dash==2.18.1