steer-core 0.1.28__tar.gz → 0.1.32__tar.gz

{steer_core-0.1.28 → steer_core-0.1.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steer-core
-Version: 0.1.28
+Version: 0.1.32
 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>

{steer_core-0.1.28/steer_core → steer_core-0.1.32/steer_core/Data}/DataManager.py

@@ -1,15 +1,20 @@
 import sqlite3 as sql
 from pathlib import Path
+from typing import TypeVar
 import pandas as pd
 import importlib.resources
 
 from steer_core.Constants.Units import *
+from steer_core.Mixins.Serializer import SerializerMixin
+
+
+T = TypeVar('T', bound='SerializerMixin')
 
 
 class DataManager:
     
     def __init__(self):
-        with importlib.resources.path("steer_core.Data", "database.db") as db_path:
+        with importlib.resources.path("steer_opencell_data", "database.db") as db_path:
             self._db_path = db_path
             self._connection = sql.connect(self._db_path)
             self._cursor = self._connection.cursor()
@@ -356,5 +361,75 @@ class DataManager:
         self._cursor.execute(f"DELETE FROM {table_name} WHERE {condition}")
         self._connection.commit()
 
+
+    @classmethod
+    def from_database(cls: type[T], name: str, table_name: str = None) -> T:
+        """
+        Pull object from the database by name.
+        
+        Subclasses must define a '_table_name' class variable (str or list of str)
+        unless table_name is explicitly provided.
+
+        Parameters
+        ----------
+        name : str
+            Name of the object to retrieve.
+        table_name : str, optional
+            Specific table to search. If provided, '_table_name' is not required.
+            If None, uses class's _table_name.
+
+        Returns
+        -------
+        T
+            Instance of the class.
+            
+        Raises
+        ------
+        NotImplementedError
+            If the subclass doesn't define '_table_name' and table_name is not provided.
+        ValueError
+            If the object name is not found in any of the tables.
+        """
+        database = cls()
+        
+        # Get list of tables to search
+        if table_name:
+            tables_to_search = [table_name]
+        else:
+            # Only check for _table_name if table_name wasn't provided
+            if not hasattr(cls, '_table_name'):
+                raise NotImplementedError(
+                    f"{cls.__name__} must define a '_table_name' class variable "
+                    "or provide 'table_name' argument"
+                )
+            
+            if isinstance(cls._table_name, (list, tuple)):
+                tables_to_search = cls._table_name
+            else:
+                tables_to_search = [cls._table_name]
+        
+        # Try each table until found
+        for table in tables_to_search:
+            available_materials = database.get_unique_values(table, "name")
+            
+            if name in available_materials:
+                data = database.get_data(table, condition=f"name = '{name}'")
+                serialized_bytes = data["object"].iloc[0]
+                return cls.deserialize(serialized_bytes)
+        
+        # Not found in any table
+        all_available = []
+        for table in tables_to_search:
+            all_available.extend(database.get_unique_values(table, "name"))
+        
+        raise ValueError(
+            f"'{name}' not found in tables {tables_to_search}. "
+            f"Available: {all_available}"
+        )
+        
+
+
     def __del__(self):
         self._connection.close()
+
+

{steer_core-0.1.28 → steer_core-0.1.32}/steer_core/Mixins/Coordinates.py

@@ -136,25 +136,39 @@ class CoordinateMixin:
         center: tuple = None
     ) -> np.ndarray:
         """
-        Rotate a (N, 3) NumPy array of 3D coordinates around the specified axis.
+        Rotate a NumPy array of coordinates around the specified axis.
+        Can handle 2D coordinates (N, 2) for x, y or 3D coordinates (N, 3) for x, y, z.
         Can handle coordinates with None values (preserves None positions).
 
-        :param coords: NumPy array of shape (N, 3), where columns are x, y, z
-        :param axis: Axis to rotate around ('x', 'y', or 'z')
+        :param coords: NumPy array of shape (N, 2) for 2D or (N, 3) for 3D coordinates
+        :param axis: Axis to rotate around ('x', 'y', or 'z'). For 2D arrays, only 'z' is valid.
         :param angle: Angle in degrees
-        :param center: Point to rotate around as (x, y, z) tuple. If None, rotates around origin.
-        :return: Rotated NumPy array of shape (N, 3)
+        :param center: Point to rotate around. For 2D: (x, y) tuple. For 3D: (x, y, z) tuple. 
+                      If None, rotates around origin.
+        :return: Rotated NumPy array with same shape as input
         """
-        if coords.shape[1] != 3:
+        # Check if 2D or 3D coordinates
+        is_2d = coords.shape[1] == 2
+        is_3d = coords.shape[1] == 3
+        
+        if not (is_2d or is_3d):
+            raise ValueError(
+                "Input array must have shape (N, 2) for 2D or (N, 3) for 3D coordinates"
+            )
+        
+        # For 2D arrays, only z-axis rotation is valid
+        if is_2d and axis != 'z':
             raise ValueError(
-                "Input array must have shape (N, 3) for x, y, z coordinates"
+                "For 2D coordinates (x, y), only 'z' axis rotation is supported"
             )
 
         # Validate center parameter
         if center is not None:
-            if not isinstance(center, (tuple, list)) or len(center) != 3:
+            expected_len = 2 if is_2d else 3
+            if not isinstance(center, (tuple, list)) or len(center) != expected_len:
+                coord_type = "(x, y)" if is_2d else "(x, y, z)"
                 raise ValueError(
-                    "Center must be a tuple or list of 3 coordinates (x, y, z)"
+                    f"Center must be a tuple or list of {expected_len} coordinates {coord_type}"
                 )
             if not all(isinstance(coord, (int, float)) for coord in center):
                 raise TypeError("All center coordinates must be numbers")
@@ -204,10 +218,11 @@ class CoordinateMixin:
         """
         Rotate coordinates around a specified center point.
 
-        :param coords: NumPy array of shape (N, 3) with valid coordinates
+        :param coords: NumPy array of shape (N, 2) or (N, 3) with valid coordinates
         :param axis: Axis to rotate around ('x', 'y', or 'z')
         :param angle: Angle in degrees
-        :param center: Center point as np.array of shape (3,). If None, rotates around origin.
+        :param center: Center point as np.array. Shape (2,) for 2D or (3,) for 3D. 
+                      If None, rotates around origin.
         :return: Rotated coordinates
         """
         if center is None:
@@ -294,13 +309,37 @@ class CoordinateMixin:
     @staticmethod
     def order_coordinates_clockwise(df: pd.DataFrame, plane="xy") -> pd.DataFrame:
 
+        df = df.copy()
+
         axis_1 = plane[0]
         axis_2 = plane[1]
 
-        cx = df[axis_1].mean()
-        cy = df[axis_2].mean()
-
-        angles = np.arctan2(df[axis_2] - cy, df[axis_1] - cx)
+        # Find column names that match the axis (case-insensitive, with or without units)
+        def find_column(axis_char: str) -> str:
+            axis_char_lower = axis_char.lower()
+            # First try exact match
+            if axis_char in df.columns:
+                return axis_char
+            # Try lowercase
+            if axis_char_lower in df.columns:
+                return axis_char_lower
+            # Try uppercase
+            if axis_char.upper() in df.columns:
+                return axis_char.upper()
+            # Try with units pattern like "X (mm)", "x (mm)", etc.
+            for col in df.columns:
+                col_stripped = col.split()[0].lower() if ' ' in col else col.lower()
+                if col_stripped == axis_char_lower:
+                    return col
+            raise KeyError(f"Could not find column for axis '{axis_char}' in dataframe columns: {list(df.columns)}")
+        
+        axis_1_col = find_column(axis_1)
+        axis_2_col = find_column(axis_2)
+
+        cx = df[axis_1_col].mean()
+        cy = df[axis_2_col].mean()
+
+        angles = np.arctan2(df[axis_2_col] - cy, df[axis_1_col] - cx)
 
         df["angle"] = angles
 
@@ -533,19 +572,35 @@ class CoordinateMixin:
     ) -> np.ndarray:
         """
         Rotate coordinates without None values using rotation matrices.
+        Handles both 2D (N, 2) and 3D (N, 3) coordinate arrays.
+        
+        :param coords: NumPy array of shape (N, 2) or (N, 3)
+        :param axis: Axis to rotate around ('x', 'y', or 'z')
+        :param angle: Angle in degrees
+        :return: Rotated coordinates with same shape as input
         """
         angle_rad = np.radians(angle)
         cos_a = np.cos(angle_rad)
         sin_a = np.sin(angle_rad)
+        
+        is_2d = coords.shape[1] == 2
 
-        if axis == "x":
-            R = np.array([[1, 0, 0], [0, cos_a, -sin_a], [0, sin_a, cos_a]])
-        elif axis == "y":
-            R = np.array([[cos_a, 0, sin_a], [0, 1, 0], [-sin_a, 0, cos_a]])
-        elif axis == "z":
-            R = np.array([[cos_a, -sin_a, 0], [sin_a, cos_a, 0], [0, 0, 1]])
+        if is_2d:
+            # For 2D coordinates, only z-axis rotation applies (rotation in xy plane)
+            if axis != 'z':
+                raise ValueError("For 2D coordinates, only 'z' axis rotation is supported")
+            # 2D rotation matrix
+            R = np.array([[cos_a, -sin_a], [sin_a, cos_a]])
         else:
-            raise ValueError("Axis must be 'x', 'y', or 'z'.")
+            # 3D rotation matrices
+            if axis == "x":
+                R = np.array([[1, 0, 0], [0, cos_a, -sin_a], [0, sin_a, cos_a]])
+            elif axis == "y":
+                R = np.array([[cos_a, 0, sin_a], [0, 1, 0], [-sin_a, 0, cos_a]])
+            elif axis == "z":
+                R = np.array([[cos_a, -sin_a, 0], [sin_a, cos_a, 0], [0, 0, 1]])
+            else:
+                raise ValueError("Axis must be 'x', 'y', or 'z'.")
 
         return coords @ R.T
 

{steer_core-0.1.28 → steer_core-0.1.32}/steer_core/Mixins/Plotter.py

@@ -36,6 +36,7 @@ class PlotterMixin:
 
     SCHEMATIC_Z_AXIS = dict(
         zeroline=False,
+        scaleanchor="x",
         title="Z (mm)"
     )
 
@@ -55,7 +56,8 @@ class PlotterMixin:
             line_width, 
             color_func, 
             unit_conversion_factor,
-            order_clockwise: str = None
+            order_clockwise: str = None,
+            gl: bool = False
             ):
         """
         Create a single trace for a component or group of components with NaN separators.
@@ -115,17 +117,30 @@ class PlotterMixin:
         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,
-        )
+        if gl:
+            return go.Scattergl(
+                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,
+            )
+        else:
+            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(
@@ -133,6 +148,7 @@ class PlotterMixin:
         title: str = "Breakdown",
         root_label: str = "Total",
         unit: str = "",
+        colorway: List[str] = None,
         **kwargs,
     ) -> go.Figure:
         """
@@ -149,12 +165,22 @@ class PlotterMixin:
             Label for the root node. Defaults to "Total".
         unit : str, optional
             Unit string to display in hover text (e.g., "g", "kg", "%"). Defaults to "".
+        colorway : List[str], optional
+            List of colors to use for the inner ring. If None, uses Plotly's default colorway.
+            Defaults to None.
 
         Returns
         -------
         go.Figure
             Plotly sunburst figure
         """
+        
+        # Default Plotly colorway if none provided
+        if colorway is None:
+            colorway = [
+                '#636EFA', '#EF553B', '#00CC96', '#AB63FA', '#FFA15A',
+                '#19D3F3', '#FF6692', '#B6E880', '#FF97FF', '#FECB52'
+            ]
 
         def _flatten_breakdown_values(data: Dict[str, Any]) -> List[float]:
             """Recursively flatten all numeric values from nested breakdown dictionary"""
@@ -177,13 +203,14 @@ class PlotterMixin:
             return total
 
         def _prepare_sunburst_data(
-            data: Dict[str, Any], parent_id: str = "", current_path: str = ""
-        ) -> Tuple[List[str], List[str], List[str], List[float]]:
+            data: Dict[str, Any], parent_id: str = "", current_path: str = "", depth: int = 1
+        ) -> Tuple[List[str], List[str], List[str], List[float], List[int]]:
             """Recursively prepare data for sunburst plot with proper hierarchy"""
             ids = []
             labels = []
             parents = []
             values = []
+            depths = []
 
             for key, value in data.items():
                 # Create unique ID for this node
@@ -192,6 +219,7 @@ class PlotterMixin:
                 ids.append(node_id)
                 labels.append(key)
                 parents.append(parent_id)
+                depths.append(depth)
 
                 if isinstance(value, dict):
                     # This is a nested dictionary - calculate its total value
@@ -204,8 +232,9 @@ class PlotterMixin:
                         nested_labels,
                         nested_parents,
                         nested_values,
+                        nested_depths,
                     ) = _prepare_sunburst_data(
-                        value, parent_id=node_id, current_path=node_id
+                        value, parent_id=node_id, current_path=node_id, depth=depth + 1
                     )
 
                     # Add nested data to our lists
@@ -213,18 +242,19 @@ class PlotterMixin:
                     labels.extend(nested_labels)
                     parents.extend(nested_parents)
                     values.extend(nested_values)
+                    depths.extend(nested_depths)
 
                 elif isinstance(value, (int, float)):
                     # This is a leaf node with a numeric value
                     values.append(float(value))
 
-            return ids, labels, parents, values
+            return ids, labels, parents, values, depths
 
         # Calculate total value for root node
         total_value = _calculate_subtotal(breakdown_dict)
 
         # Prepare hierarchical data starting with root
-        ids, labels, parents, values = _prepare_sunburst_data(
+        ids, labels, parents, values, depths = _prepare_sunburst_data(
             breakdown_dict, parent_id=""
         )
 
@@ -233,12 +263,74 @@ class PlotterMixin:
         labels.insert(0, root_label)
         parents.insert(0, "")
         values.insert(0, total_value)
+        depths.insert(0, 0)
 
         # Update parent references to point to root
         for i in range(1, len(parents)):
             if parents[i] == "":
                 parents[i] = root_label
 
+        # Generate colors based on alphabetical ordering and depth
+        def _hex_to_rgb(hex_color: str) -> Tuple[int, int, int]:
+            """Convert hex color to RGB tuple"""
+            hex_color = hex_color.lstrip('#')
+            return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+        
+        def _rgb_to_hex(rgb: Tuple[int, int, int]) -> str:
+            """Convert RGB tuple to hex color"""
+            return '#{:02x}{:02x}{:02x}'.format(int(rgb[0]), int(rgb[1]), int(rgb[2]))
+        
+        def _lighten_color(hex_color: str, factor: float) -> str:
+            """Lighten a color by blending with white. Factor 0=original, 1=white"""
+            r, g, b = _hex_to_rgb(hex_color)
+            # Blend with white (255, 255, 255)
+            r = r + (255 - r) * factor
+            g = g + (255 - g) * factor
+            b = b + (255 - b) * factor
+            return _rgb_to_hex((r, g, b))
+        
+        # Get first-level keys (children of root) and sort alphabetically
+        first_level_keys = sorted([key for key in breakdown_dict.keys()])
+        
+        # Assign base colors to first-level keys
+        key_to_base_color = {}
+        for i, key in enumerate(first_level_keys):
+            key_to_base_color[key] = colorway[i % len(colorway)]
+        
+        # Assign colors to all nodes
+        marker_colors = []
+        max_depth = max(depths) if depths else 0
+        
+        for i, (node_id, label, parent, depth) in enumerate(zip(ids, labels, parents, depths)):
+            if depth == 0:
+                # Root node - use neutral color
+                marker_colors.append('#CCCCCC')
+            elif depth == 1:
+                # First level - use assigned base color
+                marker_colors.append(key_to_base_color[label])
+            else:
+                # Deeper levels - find the first-level ancestor and lighten its color
+                # Trace back through parents to find first-level ancestor
+                current_parent = parent
+                ancestor_label = None
+                
+                for j, (check_id, check_label, check_depth) in enumerate(zip(ids, labels, depths)):
+                    if check_id == current_parent:
+                        if check_depth == 1:
+                            ancestor_label = check_label
+                            break
+                        current_parent = parents[j]
+                
+                if ancestor_label and ancestor_label in key_to_base_color:
+                    base_color = key_to_base_color[ancestor_label]
+                    # Lighten based on depth (depth 2 gets 0.3, depth 3 gets 0.5, depth 4 gets 0.7, etc.)
+                    lighten_factor = 0.2 + (depth - 1) * 0.25
+                    lighten_factor = min(lighten_factor, 0.85)  # Cap at 0.85 to avoid too pale
+                    marker_colors.append(_lighten_color(base_color, lighten_factor))
+                else:
+                    # Fallback to neutral color
+                    marker_colors.append('#DDDDDD')
+
         # Create custom hover text with percentages
         hover_text = []
         for i, (label, value) in enumerate(zip(labels, values)):
@@ -262,6 +354,7 @@ class PlotterMixin:
                 branchvalues="total",
                 hovertemplate="%{customdata}<extra></extra>",
                 customdata=hover_text,
+                marker=dict(colors=marker_colors),
             )
         )
 
@@ -273,3 +366,5 @@ class PlotterMixin:
 
 
     
+
+

steer_core-0.1.32/steer_core/Mixins/Serializer.py

@@ -0,0 +1,281 @@
+import msgpack
+import msgpack_numpy as m
+import zlib
+from typing import TypeVar, Any
+from datetime import datetime
+from enum import Enum
+
+T = TypeVar('T', bound='SerializerMixin')
+
+
+class SerializerMixin:
+    
+    def serialize(self, compress: bool = True) -> bytes:
+        """
+        Serialize object using MessagePack with numpy support.
+
+        Parameters
+        ----------
+        compress : bool, optional
+            Whether to compress the serialized data (default: True)
+
+        Returns
+        -------
+        bytes
+            The serialized byte representation of the object.
+        """
+        m.patch()  # Enable numpy support
+        data = msgpack.packb(self._to_dict(), use_bin_type=True)
+        
+        if compress:
+            # Add marker byte to indicate compression
+            return b'\x01' + zlib.compress(data, level=6)
+        else:
+            return b'\x00' + data
+    
+    def _serialize_value(self, value: Any) -> Any:
+        """
+        Recursively serialize a value, handling nested structures.
+        
+        Parameters
+        ----------
+        value : Any
+            The value to serialize.
+            
+        Returns
+        -------
+        Any
+            The serialized representation.
+        """
+        if hasattr(value, '_to_dict'):
+            # Add marker and class info for object reconstruction
+            return {
+                '__object__': True,
+                '_class': f"{value.__class__.__module__}.{value.__class__.__name__}",
+                **value._to_dict()
+            }
+        elif isinstance(value, datetime):
+            return {'__datetime__': value.isoformat()}
+        elif isinstance(value, Enum):
+            return {
+                '__enum__': True,
+                'class': f"{value.__class__.__module__}.{value.__class__.__name__}",
+                'value': value.value
+            }
+        elif isinstance(value, tuple):
+            # Recursively serialize tuple items
+            return {
+                '__tuple__': True,
+                'items': [self._serialize_value(item) for item in value]
+            }
+        elif isinstance(value, list):
+            # Recursively serialize list items
+            return [self._serialize_value(item) for item in value]
+        elif isinstance(value, dict):
+            # Handle dictionaries with object keys or values
+            has_object_keys = value and any(hasattr(k, '_to_dict') for k in value.keys())
+            has_object_values = value and any(hasattr(v, '_to_dict') for v in value.values())
+            
+            if has_object_keys or has_object_values:
+                return {
+                    '__object_dict__': True,
+                    'items': [
+                        {
+                            'key': self._serialize_value(k),
+                            'value': self._serialize_value(v)
+                        }
+                        for k, v in value.items()
+                    ]
+                }
+            else:
+                # Recursively serialize regular dict values
+                return {k: self._serialize_value(v) for k, v in value.items()}
+        else:
+            return value
+    
+    def _to_dict(self) -> dict:
+        """
+        Convert object to dictionary for serialization.
+        Override this in subclasses to customize serialization behavior.
+        
+        Returns
+        -------
+        dict
+            Dictionary representation of the object.
+        """
+        result = {}
+        for key, value in self.__dict__.items():
+            result[key] = self._serialize_value(value)
+        return result
+    
+    @classmethod
+    def deserialize(cls: type[T], data: bytes) -> T:
+        """
+        Deserialize byte data into an object.
+        Automatically detects and decompresses if needed.
+
+        Parameters
+        ----------
+        data : bytes
+            The byte data to deserialize.
+
+        Returns
+        -------
+        T
+            Instance of the class.
+        """
+        m.patch()  # Enable numpy support
+        
+        # Check compression marker
+        if data[0:1] == b'\x01':
+            data = zlib.decompress(data[1:])
+        else:
+            data = data[1:]
+        
+        obj_dict = msgpack.unpackb(data, raw=False)
+        return cls._from_dict(obj_dict)
+    
+    @classmethod
+    def _deserialize_value(cls, value: Any) -> Any:
+        """
+        Recursively deserialize a value, handling nested structures.
+        
+        Parameters
+        ----------
+        value : Any
+            The value to deserialize.
+            
+        Returns
+        -------
+        Any
+            The deserialized object.
+        """
+        if isinstance(value, dict):
+            if '__datetime__' in value:
+                return datetime.fromisoformat(value['__datetime__'])
+            elif '__enum__' in value:
+                # Reconstruct enum
+                module_name, class_name = value['class'].rsplit('.', 1)
+                import importlib
+                module = importlib.import_module(module_name)
+                enum_class = getattr(module, class_name)
+                return enum_class(value['value'])
+            elif '__tuple__' in value:
+                # Recursively reconstruct tuple items
+                return tuple(cls._deserialize_value(item) for item in value['items'])
+            elif '__object__' in value:
+                # Reconstruct regular object
+                import importlib
+                module_name, class_name = value['_class'].rsplit('.', 1)
+                module = importlib.import_module(module_name)
+                obj_class = getattr(module, class_name)
+                # Remove marker fields before passing to _from_dict
+                obj_data = {k: v for k, v in value.items() if k not in ('__object__', '_class')}
+                return obj_class._from_dict(obj_data)
+            elif '__object_dict__' in value:
+                # Reconstruct dictionary with object keys or values
+                reconstructed_dict = {}
+                for item in value['items']:
+                    key_obj = cls._deserialize_value(item['key'])
+                    value_obj = cls._deserialize_value(item['value'])
+                    reconstructed_dict[key_obj] = value_obj
+                return reconstructed_dict
+            else:
+                # Recursively deserialize regular dict values
+                return {k: cls._deserialize_value(v) for k, v in value.items()}
+        elif isinstance(value, list):
+            # Recursively deserialize list items
+            return [cls._deserialize_value(item) for item in value]
+        else:
+            return value
+    
+    @classmethod
+    def _from_dict(cls: type[T], data: dict) -> T:
+        """
+        Reconstruct object from dictionary.
+        Override in subclasses for custom deserialization.
+        
+        Parameters
+        ----------
+        data : dict
+            Dictionary representation to reconstruct from.
+            
+        Returns
+        -------
+        T
+            Reconstructed object instance.
+        """
+        obj = cls.__new__(cls)
+        reconstructed = {}
+        for key, value in data.items():
+            reconstructed[key] = cls._deserialize_value(value)
+        obj.__dict__.update(reconstructed)
+        return obj
+        
+    @classmethod
+    def from_database(cls: type[T], name: str, table_name: str = None) -> T:
+        """
+        Pull object from the database by name.
+        
+        Subclasses must define a '_table_name' class variable (str or list of str)
+        unless table_name is explicitly provided.
+
+        Parameters
+        ----------
+        name : str
+            Name of the object to retrieve.
+        table_name : str, optional
+            Specific table to search. If provided, '_table_name' is not required.
+            If None, uses class's _table_name.
+
+        Returns
+        -------
+        T
+            Instance of the class.
+            
+        Raises
+        ------
+        NotImplementedError
+            If the subclass doesn't define '_table_name' and table_name is not provided.
+        ValueError
+            If the object name is not found in any of the tables.
+        """
+        from steer_core.Data.DataManager import DataManager
+        
+        database = DataManager()
+        
+        # Get list of tables to search
+        if table_name:
+            tables_to_search = [table_name]
+        else:
+            # Only check for _table_name if table_name wasn't provided
+            if not hasattr(cls, '_table_name'):
+                raise NotImplementedError(
+                    f"{cls.__name__} must define a '_table_name' class variable "
+                    "or provide 'table_name' argument"
+                )
+            
+            if isinstance(cls._table_name, (list, tuple)):
+                tables_to_search = cls._table_name
+            else:
+                tables_to_search = [cls._table_name]
+        
+        # Try each table until found
+        for table in tables_to_search:
+            available_materials = database.get_unique_values(table, "name")
+            
+            if name in available_materials:
+                data = database.get_data(table, condition=f"name = '{name}'")
+                serialized_bytes = data["object"].iloc[0]
+                return cls.deserialize(serialized_bytes)
+        
+        # Not found in any table
+        all_available = []
+        for table in tables_to_search:
+            all_available.extend(database.get_unique_values(table, "name"))
+        
+        raise ValueError(
+            f"'{name}' not found in tables {tables_to_search}. "
+            f"Available: {all_available}"
+        )
+        

{steer_core-0.1.28 → steer_core-0.1.32}/steer_core/Mixins/TypeChecker.py

@@ -208,8 +208,9 @@ class ValidationMixin:
         ValueError
             If the value is not a positive float.
         """
+        value = float(value)  # Ensure value is float
         if not isinstance(value, (int, float)):
-            raise ValueError(f"{name} must be a positive float. Provided: {value}.")
+            raise ValueError(f"{name} must be a positive float. Provided: {value} of type {type(value).__name__}.")
 
     @staticmethod
     def validate_positive_int(value: int, name: str) -> None:

{steer_core-0.1.28 → steer_core-0.1.32}/steer_core/__init__.py

@@ -1,7 +1,4 @@
-__version__ = "0.1.28"
-
-# datamanager import
-from .DataManager import DataManager
+__version__ = "0.1.32"
 
 from .Mixins.Colors import ColorMixin
 from .Mixins.Coordinates import CoordinateMixin

{steer_core-0.1.28 → steer_core-0.1.32}/steer_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steer-core
-Version: 0.1.28
+Version: 0.1.32
 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>

{steer_core-0.1.28 → steer_core-0.1.32}/steer_core.egg-info/SOURCES.txt

@@ -1,6 +1,5 @@
 README.md
 pyproject.toml
-steer_core/DataManager.py
 steer_core/__init__.py
 steer_core.egg-info/PKG-INFO
 steer_core.egg-info/SOURCES.txt
@@ -12,8 +11,8 @@ steer_core/Constants/Universal.py
 steer_core/Constants/__init__.py
 steer_core/ContextManagers/ContextManagers.py
 steer_core/ContextManagers/__init__.py
+steer_core/Data/DataManager.py
 steer_core/Data/__init__.py
-steer_core/Data/database.db
 steer_core/Decorators/Coordinates.py
 steer_core/Decorators/General.py
 steer_core/Decorators/Objects.py

steer_core-0.1.28/steer_core/Mixins/Serializer.py

@@ -1,45 +0,0 @@
-import base64
-from pickle import loads, dumps
-from typing import Type
-from copy import deepcopy
-
-
-class SerializerMixin:
-    def serialize(self) -> str:
-        """
-        Serialize an object to a string representation.
-
-        Parameters
-        ----------
-        obj : Type
-            The object to serialize.
-
-        Returns
-        -------
-        str
-            The serialized string representation of the object.
-        """
-        pickled = dumps(self)
-        based = base64.b64encode(pickled).decode("utf-8")
-        return based
-
-    @staticmethod
-    def deserialize(String: str) -> Type:
-        """
-        Deserialize a string representation into an object.
-
-        Parameters
-        ----------
-        String : str
-            The string representation to deserialize.
-
-        Returns
-        -------
-        SerializerMixin
-            The deserialized object.
-        """
-        decoded = base64.b64decode(String.encode("utf-8"))
-        obj = deepcopy(loads(decoded))
-        return obj
-
-