steer-core 0.1.18__tar.gz → 0.1.20__tar.gz

{steer_core-0.1.18 → steer_core-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steer-core
-Version: 0.1.18
+Version: 0.1.20
 Summary: Modelling energy storage from cell to site - STEER OpenCell Design
 Home-page: https://github.com/nicholas9182/steer-core/
 Author: Nicholas Siemons

{steer_core-0.1.18 → steer_core-0.1.20}/steer_core/Decorators/Electrochemical.py

@@ -1,19 +1,16 @@
 from functools import wraps
 
-
 def calculate_half_cell_curve(func):
     """
     Decorator to recalculate half-cell curve properties after a method call.
     This is useful for methods that modify the half-cell curve data.
     """
-
     @wraps(func)
     def wrapper(self, *args, **kwargs):
         result = func(self, *args, **kwargs)
-        if hasattr(self, "_update_properties") and self._update_properties:
+        if hasattr(self, '_update_properties') and self._update_properties:
             self._calculate_half_cell_curve()
         return result
-
     return wrapper
 
 
@@ -22,12 +19,11 @@ def calculate_half_cell_curves_properties(func):
     Decorator to recalculate half-cell curves properties after a method call.
     This is useful for methods that modify the half-cell curves data.
     """
-
     @wraps(func)
     def wrapper(self, *args, **kwargs):
         result = func(self, *args, **kwargs)
-        if hasattr(self, "_update_properties") and self._update_properties:
+        if hasattr(self, '_update_properties') and self._update_properties:
             self._calculate_half_cell_curves_properties()
         return result
-
     return wrapper
+

{steer_core-0.1.18 → steer_core-0.1.20}/steer_core/Decorators/General.py

@@ -31,3 +31,4 @@ def calculate_all_properties(func):
         return result
 
     return wrapper
+

steer_core-0.1.20/steer_core/Mixins/Dunder.py

@@ -0,0 +1,164 @@
+
+
+import numpy as np
+
+
+class DunderMixin:
+
+    def _get_comparable_properties(self):
+        """Get all comparable properties from the class hierarchy."""
+        properties = []
+        for cls in self.__class__.__mro__:
+            for name, value in cls.__dict__.items():
+                if isinstance(value, property):
+                    if not self._should_exclude_property(name):
+                        properties.append(name)
+        return properties
+
+    def _should_exclude_property(self, name):
+        """Check if a property should be excluded from comparison."""
+        return (
+            name.endswith('_trace') or
+            name.endswith('_range') or 
+            name in {'last_updated', 'properties'}
+        )
+
+    def _is_plotly_trace(self, obj):
+        """Check if object is a Plotly trace object."""
+        return (
+            hasattr(obj, '__module__') and 
+            obj.__module__ and 
+            obj.__module__.startswith('plotly.graph_objs')
+        )
+
+    def _compare_none_values(self, self_value, other_value):
+        """Compare None values. Returns (should_continue, result)."""
+        if self_value is None and other_value is None:
+            return True, True  # Continue, values are equal
+        elif self_value is None or other_value is None:
+            return False, False  # Stop, values are not equal
+        return True, None  # Continue, not None values
+
+    def _compare_plotly_traces(self, self_value, other_value):
+        """Compare Plotly trace objects. Returns (should_continue, result)."""
+        if self._is_plotly_trace(self_value) or self._is_plotly_trace(other_value):
+            return True, True  # Skip Plotly traces, continue
+        return True, None  # Continue, not Plotly traces
+
+    def _compare_numpy_arrays(self, self_value, other_value):
+        """Compare NumPy arrays. Returns (should_continue, result)."""
+        if isinstance(self_value, np.ndarray) and isinstance(other_value, np.ndarray):
+            return False, np.array_equal(self_value, other_value, equal_nan=True)
+        elif isinstance(self_value, np.ndarray) or isinstance(other_value, np.ndarray):
+            return False, False  # One is numpy array, other is not
+        return True, None  # Continue, not numpy arrays
+
+    def _compare_dataframes(self, self_value, other_value):
+        """Compare pandas DataFrames/Series. Returns (should_continue, result)."""
+        if hasattr(self_value, 'equals') and hasattr(other_value, 'equals'):
+            return False, self_value.equals(other_value)
+        elif hasattr(self_value, 'equals') or hasattr(other_value, 'equals'):
+            return False, False  # Only one is a DataFrame/Series
+        return True, None  # Continue, not DataFrames
+
+    def _compare_dictionaries(self, self_value, other_value):
+        """Compare dictionaries by comparing keys and values separately. Returns (should_continue, result)."""
+        if isinstance(self_value, dict) and isinstance(other_value, dict):
+            # Compare keys first (order-independent)
+            if list(self_value.keys()) == list(other_value.keys()) and list(self_value.values()) == list(other_value.values()):
+                return False, True  # Quick path: both keys and values match in order
+            
+            # Compare values for each key
+            for key in self_value.keys():
+                if self_value[key] != other_value[key]:
+                    return False, False
+            
+            return False, True  # Dictionaries are equal
+        elif isinstance(self_value, dict) or isinstance(other_value, dict):
+            return False, False  # One is dict, other is not
+        return True, None  # Continue, not dictionaries
+
+    def _compare_sequences(self, self_value, other_value):
+        """Compare lists and tuples. Returns (should_continue, result)."""
+        if isinstance(self_value, (list, tuple)) and isinstance(other_value, (list, tuple)):
+            return False, type(self_value) == type(other_value) and self_value == other_value
+        elif isinstance(self_value, (list, tuple)) or isinstance(other_value, (list, tuple)):
+            return False, False  # One is sequence, other is not
+        return True, None  # Continue, not sequences
+
+    def _compare_other_types(self, self_value, other_value):
+        """Compare all other types. Returns (should_continue, result)."""
+        return False, self_value == other_value
+
+    def __eq__(self, other):
+        """
+        Compare two instances based on all their @property decorated attributes.
+        
+        Returns True if all properties have equal values, False otherwise.
+        Returns False if other is not an instance of the same class.
+        """
+        # Quick identity check first (performance optimization)
+        if self is other:
+            return True
+            
+        # Check if other is the same type
+        if type(other) != type(self):
+            return False
+        
+        # Cache properties to avoid repeated computation (performance optimization)
+        if not hasattr(self, '_cached_properties'):
+            self._cached_properties = self._get_comparable_properties()
+        
+        # Define comparison methods in order of priority/frequency
+        comparison_methods = [
+            self._compare_none_values,
+            self._compare_plotly_traces,
+            self._compare_numpy_arrays,
+            self._compare_dataframes,
+            self._compare_dictionaries,
+            self._compare_sequences,
+            self._compare_other_types,
+        ]
+
+        # Compare all property values
+        for prop_name in self._cached_properties:
+
+            try:
+                self_value = getattr(self, prop_name)
+                other_value = getattr(other, prop_name)
+                
+                # Execute comparison methods until one handles the values
+                for method in comparison_methods:
+                    should_continue, result = method(self_value, other_value)
+                    if not should_continue:
+                        if not result:
+                            return False
+                        break  # Values are equal, continue to next property
+                        
+            except (AttributeError, Exception):
+                # If property doesn't exist or comparison fails
+                return False
+        
+        return True
+    
+    def __hash__(self):
+        """
+        Simple, robust hash based on object identity.
+        
+        Uses id() for a fast, guaranteed-unique hash that won't fail.
+        Objects are only equal if they're the same instance.
+        """
+        return hash(id(self))
+    
+    def __str__(self):
+        """
+        String representation of the instance showing all @property decorated attributes and their values.
+        """
+        return f"{self.__class__.__name__}, {self.__name__}"
+    
+    def __repr__(self):
+        """
+        Official string representation of the instance.
+        """
+        return self.__str__()
+

{steer_core-0.1.18 → steer_core-0.1.20}/steer_core/Mixins/TypeChecker.py

@@ -1,12 +1,37 @@
 from typing import Type
 import pandas as pd
 import numpy as np
+import plotly.graph_objects as go
 
 
 ALLOWED_REFERENCE = ["Na/Na+", "Li/Li+"]
 
 
 class ValidationMixin:
+
+    @staticmethod
+    def validate_plotly_trace(value: object, name: str) -> None:
+        """
+        Validate that a value is a Plotly trace object.
+
+        Parameters
+        ----------
+        value : object
+            The value to validate.
+        name : str
+            The name of the parameter for error messages.
+
+        Raises
+        ------
+        TypeError
+            If the value is not a Plotly trace object.
+        """
+        return (
+            hasattr(value, '__module__') and
+            value.__module__ and 
+            value.__module__.startswith('plotly.graph_objs')
+        )
+        
     @staticmethod
     def validate_type(value: Type, expected_type: Type, name: str) -> None:
         """
@@ -27,9 +52,7 @@ class ValidationMixin:
             If the value is not of the expected type.
         """
         if not isinstance(value, expected_type):
-            raise TypeError(
-                f"{name} must be of type {expected_type.__name__}. Provided: {type(value).__name__}."
-            )
+            raise TypeError(f"{name} must be of type {expected_type.__name__}. Provided: {type(value).__name__}.")
 
     @staticmethod
     def validate_percentage(value: float, name: str) -> None:

steer_core-0.1.20/steer_core/__init__.py

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

{steer_core-0.1.18 → steer_core-0.1.20}/steer_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steer-core
-Version: 0.1.18
+Version: 0.1.20
 Summary: Modelling energy storage from cell to site - STEER OpenCell Design
 Home-page: https://github.com/nicholas9182/steer-core/
 Author: Nicholas Siemons

{steer_core-0.1.18 → steer_core-0.1.20}/steer_core.egg-info/SOURCES.txt

@@ -31,10 +31,10 @@ steer_core/Decorators/__init__.py
 steer_core/Mixins/Colors.py
 steer_core/Mixins/Coordinates.py
 steer_core/Mixins/Data.py
+steer_core/Mixins/Dunder.py
 steer_core/Mixins/Plotter.py
 steer_core/Mixins/Serializer.py
 steer_core/Mixins/TypeChecker.py
 steer_core/Mixins/__init__.py
-test/test_compound_components.py
-test/test_compound_components_clean.py
-test/test_slider_controls.py
+steer_core/Mixins/serializer.py
+test/test_validation_mixin.py

steer_core-0.1.20/test/test_validation_mixin.py

@@ -0,0 +1,97 @@
+import unittest
+import plotly.graph_objects as go
+from steer_core.Mixins.TypeChecker import ValidationMixin
+
+
+class TestValidationMixin(unittest.TestCase):
+    """Test cases for ValidationMixin validation methods."""
+
+    def test_validate_plotly_trace_with_valid_traces(self):
+        """Test validate_plotly_trace with valid Plotly trace objects."""
+        # Test various Plotly trace types
+        valid_traces = [
+            go.Scatter(x=[1, 2, 3], y=[1, 2, 3]),
+            go.Bar(x=['A', 'B', 'C'], y=[1, 2, 3]),
+            go.Histogram(x=[1, 2, 3, 4, 5]),
+            go.Box(y=[1, 2, 3, 4, 5]),
+            go.Heatmap(z=[[1, 2], [3, 4]]),
+            go.Pie(values=[1, 2, 3], labels=['A', 'B', 'C']),
+            go.Scatter3d(x=[1, 2], y=[1, 2], z=[1, 2]),
+        ]
+        
+        for trace in valid_traces:
+            with self.subTest(trace=type(trace).__name__):
+                result = ValidationMixin.validate_plotly_trace(trace, "test_trace")
+                self.assertTrue(result, f"Should return True for {type(trace).__name__}")
+
+    def test_validate_plotly_trace_with_invalid_objects(self):
+        """Test validate_plotly_trace with non-Plotly objects."""
+        invalid_objects = [
+            "string",
+            123,
+            [1, 2, 3],
+            {"key": "value"},
+            None,
+            object(),
+        ]
+        
+        for obj in invalid_objects:
+            with self.subTest(obj=type(obj).__name__):
+                # Should return False for non-Plotly objects
+                result = ValidationMixin.validate_plotly_trace(obj, "test_object")
+                self.assertFalse(result, f"Should return False for {type(obj).__name__}")
+
+    def test_validate_plotly_trace_with_objects_without_module(self):
+        """Test validate_plotly_trace with objects that don't have __module__ attribute."""
+        # Create an object without __module__ using a custom class
+        class MockObjectNoModule:
+            def __getattribute__(self, name):
+                if name == '__module__':
+                    raise AttributeError(f"'{type(self).__name__}' object has no attribute '__module__'")
+                return super().__getattribute__(name)
+        
+        mock_obj = MockObjectNoModule()
+        
+        # Verify that hasattr returns False for __module__
+        self.assertFalse(hasattr(mock_obj, '__module__'), "Mock object should not have __module__ attribute")
+        
+        result = ValidationMixin.validate_plotly_trace(mock_obj, "mock_object")
+        self.assertFalse(result, "Should return False for objects without __module__")
+
+    def test_validate_plotly_trace_with_wrong_module(self):
+        """Test validate_plotly_trace with objects from different modules."""
+        import pandas as pd
+        import numpy as np
+        
+        # Test with objects from other modules
+        other_module_objects = [
+            pd.DataFrame({'x': [1, 2, 3]}),
+            np.array([1, 2, 3]),
+        ]
+        
+        for obj in other_module_objects:
+            with self.subTest(obj=type(obj).__name__):
+                result = ValidationMixin.validate_plotly_trace(obj, "other_module_object")
+                self.assertFalse(result, f"Should return False for {type(obj).__name__} from different module")
+
+    def test_validate_plotly_trace_edge_cases(self):
+        """Test validate_plotly_trace with edge cases."""
+        # Test with object that has __module__ but it's None
+        class MockObjectWithNoneModule:
+            __module__ = None
+        
+        mock_obj = MockObjectWithNoneModule()
+        result = ValidationMixin.validate_plotly_trace(mock_obj, "mock_object_none_module")
+        self.assertFalse(result, "Should return False when __module__ is None")
+        
+        # Test with object that has __module__ but it's empty string
+        class MockObjectWithEmptyModule:
+            __module__ = ""
+        
+        mock_obj_empty = MockObjectWithEmptyModule()
+        result = ValidationMixin.validate_plotly_trace(mock_obj_empty, "mock_object_empty_module")
+        self.assertFalse(result, "Should return False when __module__ is empty string")
+
+
+if __name__ == '__main__':
+    unittest.main()

steer_core-0.1.18/steer_core/__init__.py

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

steer_core-0.1.18/test/test_compound_components.py

@@ -1,339 +0,0 @@
-"""
-Unit tests for SliderWithTextInput component with built-in callback logic.
-
-Tests cover component initialization, layout generation, callback registration,
-and synchronization behavior.
-"""
-
-import unittest
-from unittest.mock import Mock, patch
-import dash
-from dash import html, dcc
-import numpy as np
-
-# Import the component
-from steer_core.Apps.Components.SliderComponents import SliderWithTextInput
-
-
-class TestSliderWithTextInput(unittest.TestCase):
-    """Test cases for SliderWithTextInput component."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-
-        self.test_id_base = {"type": "test", "index": 0}
-
-        self.component = SliderWithTextInput(
-            id_base=self.test_id_base,
-            min_val=0.0,
-            max_val=100.0,
-            step=1.0,
-            mark_interval=10.0,
-            property_name="test_prop",
-            title="Test Component",
-            default_val=50.0,
-        )
-
-    def test_initialization(self):
-        """Test component initialization and attribute assignment."""
-        self.assertEqual(self.component.id_base, self.test_id_base)
-        self.assertEqual(self.component.min_val, 0.0)
-        self.assertEqual(self.component.max_val, 100.0)
-        self.assertEqual(self.component.step, 1.0)
-        self.assertEqual(self.component.mark_interval, 10.0)
-        self.assertEqual(self.component.property_name, "test_prop")
-        self.assertEqual(self.component.title, "Test Component")
-        self.assertEqual(self.component.default_val, 50.0)
-        self.assertTrue(self.component.with_slider_titles)
-        self.assertFalse(self.component.slider_disable)
-        self.assertEqual(self.component.div_width, "calc(90%)")
-
-    def test_id_generation(self):
-        """Test ID generation for component elements."""
-        expected_slider_id = {
-            **self.test_id_base,
-            "subtype": "slider",
-            "property": "test_prop",
-        }
-        expected_input_id = {
-            **self.test_id_base,
-            "subtype": "input",
-            "property": "test_prop",
-        }
-
-        self.assertEqual(self.component.slider_id, expected_slider_id)
-        self.assertEqual(self.component.input_id, expected_input_id)
-
-    def test_make_id_method(self):
-        """Test the _make_id private method."""
-        result = self.component._make_id("custom_subtype")
-        expected = {
-            **self.test_id_base,
-            "subtype": "custom_subtype",
-            "property": "test_prop",
-        }
-        self.assertEqual(result, expected)
-
-    def test_make_slider(self):
-        """Test slider component creation."""
-        slider = self.component._make_slider()
-
-        self.assertIsInstance(slider, dcc.Slider)
-        self.assertEqual(slider.id, self.component.slider_id)
-        self.assertEqual(slider.min, 0.0)
-        self.assertEqual(slider.max, 100.0)
-        self.assertEqual(slider.value, 50.0)
-        self.assertEqual(slider.step, 1.0)
-        self.assertFalse(slider.disabled)
-        self.assertEqual(slider.updatemode, "mouseup")
-
-        # Test marks generation
-        expected_marks = {int(i): "" for i in np.arange(0.0, 110.0, 10.0)}
-        self.assertEqual(slider.marks, expected_marks)
-
-    def test_make_input(self):
-        """Test input component creation."""
-        input_comp = self.component._make_input()
-
-        self.assertIsInstance(input_comp, dcc.Input)
-        self.assertEqual(input_comp.id, self.component.input_id)
-        self.assertEqual(input_comp.type, "number")
-        self.assertEqual(input_comp.value, 50.0)
-        self.assertEqual(input_comp.step, 1.0)
-        self.assertFalse(input_comp.disabled)
-        self.assertEqual(input_comp.style, {"margin-left": "20px"})
-
-    def test_call_method(self):
-        """Test the __call__ method that generates the complete layout."""
-        layout = self.component()
-
-        self.assertIsInstance(layout, html.Div)
-        self.assertEqual(len(layout.children), 5)  # P, Div, Input, Br, Br
-
-        # Check title paragraph
-        title_p = layout.children[0]
-        self.assertIsInstance(title_p, html.P)
-        self.assertEqual(title_p.children, "Test Component")
-
-    def test_call_method_without_title(self):
-        """Test layout generation with titles disabled."""
-        self.component.with_slider_titles = False
-        layout = self.component()
-
-        title_p = layout.children[0]
-        self.assertEqual(title_p.children, "\u00A0")  # Non-breaking space
-
-    def test_components_property(self):
-        """Test the components property."""
-        components = self.component.components
-
-        expected = {
-            "slider": self.component.slider_id,
-            "input": self.component.input_id,
-        }
-        self.assertEqual(components, expected)
-
-    def test_validate_and_clamp_value(self):
-        """Test value validation and clamping."""
-        # Test normal value
-        self.assertEqual(self.component._validate_and_clamp_value(50.0), 50.0)
-
-        # Test value below minimum
-        self.assertEqual(self.component._validate_and_clamp_value(-10.0), 0.0)
-
-        # Test value above maximum
-        self.assertEqual(self.component._validate_and_clamp_value(150.0), 100.0)
-
-        # Test None value
-        self.assertEqual(self.component._validate_and_clamp_value(None), 50.0)
-
-        # Test invalid string
-        self.assertEqual(self.component._validate_and_clamp_value("invalid"), 50.0)
-
-    def test_validate_and_clamp_value_no_default(self):
-        """Test value validation when no default value is set."""
-        component = SliderWithTextInput(
-            id_base=self.test_id_base,
-            min_val=0.0,
-            max_val=100.0,
-            step=1.0,
-            mark_interval=10.0,
-            property_name="test_prop",
-            title="Test Component",
-            default_val=None,
-        )
-
-        # Should return min_val when no default and invalid input
-        self.assertEqual(component._validate_and_clamp_value(None), 0.0)
-        self.assertEqual(component._validate_and_clamp_value("invalid"), 0.0)
-
-    def test_no_automatic_callbacks(self):
-        """Test that component no longer has automatic callback registration methods."""
-        # These methods should no longer exist
-        with self.assertRaises(AttributeError):
-            self.component.register_callbacks()
-
-        with self.assertRaises(AttributeError):
-            self.component.register_clientside_callbacks()
-
-        with self.assertRaises(AttributeError):
-            SliderWithTextInput.with_sync(
-                id_base=self.test_id_base,
-                min_val=0.0,
-                max_val=100.0,
-                step=1.0,
-                mark_interval=10.0,
-                property_name="test",
-                title="Test",
-            )
-
-        # Store methods should also no longer exist
-        with self.assertRaises(AttributeError):
-            self.component.get_store_input()
-
-        with self.assertRaises(AttributeError):
-            self.component.get_store_output()
-
-        # Store ID should no longer exist
-        with self.assertRaises(AttributeError):
-            self.component.store_id
-
-    def test_disabled_components(self):
-        """Test component creation with disabled state."""
-        disabled_component = SliderWithTextInput(
-            id_base=self.test_id_base,
-            min_val=0.0,
-            max_val=100.0,
-            step=1.0,
-            mark_interval=10.0,
-            property_name="disabled_test",
-            title="Disabled Test",
-            slider_disable=True,
-        )
-
-        slider = disabled_component._make_slider()
-        input_comp = disabled_component._make_input()
-
-        self.assertTrue(slider.disabled)
-        self.assertTrue(input_comp.disabled)
-
-    def test_custom_div_width(self):
-        """Test component with custom div width."""
-        custom_component = SliderWithTextInput(
-            id_base=self.test_id_base,
-            min_val=0.0,
-            max_val=100.0,
-            step=1.0,
-            mark_interval=10.0,
-            property_name="width_test",
-            title="Width Test",
-            div_width="50%",
-        )
-
-        layout = custom_component()
-        self.assertEqual(layout.style["width"], "50%")
-
-    def test_get_value_inputs(self):
-        """Test the get_value_inputs helper method."""
-        inputs = self.component.get_value_inputs()
-
-        # Should return a list with two Input objects
-        self.assertEqual(len(inputs), 2)
-
-        # Check slider input
-        slider_input = inputs[0]
-        self.assertEqual(slider_input.component_id, self.component.slider_id)
-        self.assertEqual(slider_input.component_property, "value")
-
-        # Check input input
-        input_input = inputs[1]
-        self.assertEqual(input_input.component_id, self.component.input_id)
-        self.assertEqual(input_input.component_property, "value")
-
-    def test_get_value_outputs(self):
-        """Test the get_value_outputs helper method."""
-        outputs = self.component.get_value_outputs()
-
-        # Should return a list with two Output objects
-        self.assertEqual(len(outputs), 2)
-
-        # Check slider output
-        slider_output = outputs[0]
-        self.assertEqual(slider_output.component_id, self.component.slider_id)
-        self.assertEqual(slider_output.component_property, "value")
-
-        # Check input output
-        input_output = outputs[1]
-        self.assertEqual(input_output.component_id, self.component.input_id)
-        self.assertEqual(input_output.component_property, "value")
-
-    def test_get_pattern_matching_value_inputs(self):
-        """Test the get_pattern_matching_value_inputs helper method."""
-        inputs = self.component.get_pattern_matching_value_inputs("temperature")
-
-        # Should return a list with two Input objects
-        self.assertEqual(len(inputs), 2)
-
-        # Check pattern structure
-        slider_pattern = inputs[0].component_id
-        self.assertEqual(slider_pattern["type"], "parameter")
-        self.assertEqual(slider_pattern["subtype"], "slider")
-        self.assertEqual(slider_pattern["property"], "temperature")
-
-        input_pattern = inputs[1].component_id
-        self.assertEqual(input_pattern["type"], "parameter")
-        self.assertEqual(input_pattern["subtype"], "input")
-        self.assertEqual(input_pattern["property"], "temperature")
-
-    def test_get_pattern_matching_value_outputs(self):
-        """Test the get_pattern_matching_value_outputs helper method."""
-        outputs = self.component.get_pattern_matching_value_outputs("ALL")
-
-        # Should return a list with two Output objects
-        self.assertEqual(len(outputs), 2)
-
-        # Check pattern structure
-        slider_pattern = outputs[0].component_id
-        self.assertEqual(slider_pattern["type"], "parameter")
-        self.assertEqual(slider_pattern["subtype"], "slider")
-        self.assertEqual(slider_pattern["property"], "ALL")
-
-        input_pattern = outputs[1].component_id
-        self.assertEqual(input_pattern["type"], "parameter")
-        self.assertEqual(input_pattern["subtype"], "input")
-        self.assertEqual(input_pattern["property"], "ALL")
-
-
-class TestSliderWithTextInputIntegration(unittest.TestCase):
-    """Integration tests for SliderWithTextInput component."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.app = dash.Dash(__name__)
-        self.component = SliderWithTextInput(
-            id_base={"type": "test", "index": 0},
-            min_val=0.0,
-            max_val=100.0,
-            step=1.0,
-            mark_interval=10.0,
-            property_name="integration_test",
-            title="Integration Test Component",
-        )
-
-    def test_component_creation(self):
-        """Test that component creates correctly without auto-sync."""
-        self.assertIsInstance(self.component, SliderWithTextInput)
-        self.assertEqual(self.component.min_val, 0.0)
-        self.assertEqual(self.component.max_val, 100.0)
-        self.assertEqual(self.component.property_name, "integration_test")
-
-    def test_component_layout_generation(self):
-        """Test that the component generates proper layout."""
-        layout = self.component()
-        self.assertIsInstance(layout, html.Div)
-        # Should have title, slider div, input, and two breaks
-        self.assertEqual(len(layout.children), 5)
-
-
-if __name__ == "__main__":
-    unittest.main()

steer_core-0.1.18/test/test_slider_controls.py

@@ -1,286 +0,0 @@
-"""
-Unit tests for SliderControls utility functions.
-"""
-
-import unittest
-import math
-from steer_core.Apps.Utils.SliderControls import (
-    calculate_slider_steps,
-    calculate_mark_intervals,
-    create_slider_config,
-    snap_to_slider_grid,
-)
-
-
-class TestSliderControls(unittest.TestCase):
-    """Test cases for slider control utility functions."""
-
-    def test_calculate_slider_steps_basic(self):
-        """Test basic step calculation functionality."""
-        min_vals = [0, 0, 0]
-        max_vals = [10, 100, 1000]
-        steps = calculate_slider_steps(min_vals, max_vals)
-
-        # Should have 3 steps
-        self.assertEqual(len(steps), 3)
-
-        # Steps should be reasonable for their ranges
-        self.assertLessEqual(steps[0], 1.0)  # 10 range
-        self.assertLessEqual(steps[1], 10.0)  # 100 range
-        self.assertLessEqual(steps[2], 100.0)  # 1000 range
-
-        # All steps should be positive
-        for step in steps:
-            self.assertGreater(step, 0)
-
-    def test_calculate_slider_steps_edge_cases(self):
-        """Test edge cases for step calculation."""
-        # Zero range
-        steps = calculate_slider_steps([5], [5])
-        self.assertEqual(steps[0], 0.001)
-
-        # Very small range
-        steps = calculate_slider_steps([0], [0.001])
-        self.assertGreater(steps[0], 0)
-        self.assertLess(steps[0], 0.001)
-
-        # Negative ranges
-        steps = calculate_slider_steps([-100], [100])
-        self.assertGreater(steps[0], 0)
-
-    def test_calculate_slider_steps_validation(self):
-        """Test input validation for step calculation."""
-        # Mismatched lengths
-        with self.assertRaises(ValueError):
-            calculate_slider_steps([0, 1], [10])
-
-        # Max < min
-        with self.assertRaises(ValueError):
-            calculate_slider_steps([10], [5])
-
-    def test_calculate_mark_intervals(self):
-        """Test mark interval calculation."""
-        min_vals = [0, 0]
-        max_vals = [100, 1000]
-        intervals = calculate_mark_intervals(min_vals, max_vals)
-
-        self.assertEqual(len(intervals), 2)
-
-        # Intervals should be reasonable
-        self.assertGreater(intervals[0], 0)
-        self.assertGreater(intervals[1], 0)
-
-        # Should be larger than steps for same ranges
-        steps = calculate_slider_steps(min_vals, max_vals)
-        for interval, step in zip(intervals, steps):
-            self.assertGreaterEqual(interval, step)
-
-    def test_create_slider_config(self):
-        """Test complete slider configuration creation."""
-        min_vals = [0, 20]
-        max_vals = [100, 80]
-
-        config = create_slider_config(min_vals, max_vals)
-
-        # Check required keys
-        required_keys = [
-            "min_vals",
-            "max_vals",
-            "step_vals",
-            "input_step_vals",
-            "mark_vals",
-        ]
-        for key in required_keys:
-            self.assertIn(key, config)
-
-        # Check list lengths
-        self.assertEqual(len(config["min_vals"]), 2)
-        self.assertEqual(len(config["max_vals"]), 2)
-        self.assertEqual(len(config["step_vals"]), 2)
-        self.assertEqual(len(config["input_step_vals"]), 2)
-        self.assertEqual(len(config["mark_vals"]), 2)
-
-        # Check values - min/max should be grid-snapped but close to originals
-        # Grid-snapped min should be <= original min
-        for i, (grid_min, orig_min) in enumerate(zip(config["min_vals"], min_vals)):
-            self.assertLessEqual(grid_min, orig_min)
-            self.assertAlmostEqual(grid_min, orig_min, delta=config["step_vals"][i])
-
-        # Grid-snapped max should be >= original max
-        for i, (grid_max, orig_max) in enumerate(zip(config["max_vals"], max_vals)):
-            self.assertGreaterEqual(grid_max, orig_max)
-            self.assertAlmostEqual(grid_max, orig_max, delta=config["step_vals"][i])
-
-        # Check that step values are positive
-        for step in config["step_vals"]:
-            self.assertGreater(step, 0)
-
-        # Check that input step values are positive and slider steps are 10x larger than input steps
-        # Also check minimum step sizes: slider min 0.1, input min 0.01
-        for i, (slider_step, input_step) in enumerate(
-            zip(config["step_vals"], config["input_step_vals"])
-        ):
-            self.assertGreater(input_step, 0)
-            self.assertGreaterEqual(slider_step, 0.1)  # Minimum step size for sliders
-            self.assertGreaterEqual(input_step, 0.01)  # Minimum step size for inputs
-            # When both are above minimum, slider should be 10x larger than input
-            if input_step > 0.01:
-                self.assertAlmostEqual(slider_step, input_step * 10.0, places=10)
-
-        # Check that mark_vals contains dictionaries
-        for marks in config["mark_vals"]:
-            self.assertIsInstance(marks, dict)
-            self.assertGreater(len(marks), 0)
-
-    def test_create_slider_config_with_property_values(self):
-        """Test slider configuration with property values snapping to grid."""
-        min_vals = [0, 20]
-        max_vals = [100, 80]
-        property_vals = [23.7, 45.3]
-
-        config = create_slider_config(min_vals, max_vals, property_vals)
-
-        # Check that both grid value types are present
-        self.assertIn("grid_slider_vals", config)
-        self.assertIn("grid_input_vals", config)
-        self.assertEqual(len(config["grid_slider_vals"]), 2)
-        self.assertEqual(len(config["grid_input_vals"]), 2)
-
-        # Grid values should be properly snapped to grid (note: no longer constrained to slider range)
-        for i, (slider_grid_val, input_grid_val) in enumerate(
-            zip(config["grid_slider_vals"], config["grid_input_vals"])
-        ):
-            # Values should be snapped to their respective grids
-            slider_step = config["step_vals"][i]
-            input_step = config["input_step_vals"][i]
-
-            # Check grid alignment (values should be on grid)
-            slider_offset = (slider_grid_val - config["min_vals"][i]) % slider_step
-            input_offset = (input_grid_val - config["min_vals"][i]) % input_step
-
-            # Due to floating point precision, offset might be very close to 0 or step size
-            self.assertTrue(
-                abs(slider_offset) < 1e-10 or abs(slider_offset - slider_step) < 1e-10,
-                f"Slider value not on grid: offset={slider_offset}",
-            )
-            self.assertTrue(
-                abs(input_offset) < 1e-10 or abs(input_offset - input_step) < 1e-10,
-                f"Input value not on grid: offset={input_offset}",
-            )
-
-    def test_create_slider_config_out_of_range_values(self):
-        """Test that property values outside slider range are preserved (not clamped)."""
-        min_vals = [0, 10]
-        max_vals = [100, 50]
-        # Property values outside the ranges
-        property_vals = [150, 5]  # 150 > 100, 5 < 10
-
-        config = create_slider_config(min_vals, max_vals, property_vals)
-
-        # Values should be preserved (not clamped to range)
-        self.assertEqual(config["grid_slider_vals"][0], 150.0)  # Not clamped to 100
-        self.assertEqual(config["grid_slider_vals"][1], 5.0)  # Not clamped to 10
-        self.assertEqual(config["grid_input_vals"][0], 150.0)  # Not clamped to 100
-        self.assertEqual(config["grid_input_vals"][1], 5.0)  # Not clamped to 10
-
-        # Values should still be on grid
-        for i, (slider_val, input_val) in enumerate(
-            zip(config["grid_slider_vals"], config["grid_input_vals"])
-        ):
-            slider_step = config["step_vals"][i]
-            input_step = config["input_step_vals"][i]
-
-            # Check grid alignment
-            slider_offset = (slider_val - config["min_vals"][i]) % slider_step
-            input_offset = (input_val - config["min_vals"][i]) % input_step
-
-            # Due to floating point precision, offset might be very close to 0 or step size
-            self.assertTrue(
-                abs(slider_offset) < 1e-10 or abs(slider_offset - slider_step) < 1e-10
-            )
-            self.assertTrue(
-                abs(input_offset) < 1e-10 or abs(input_offset - input_step) < 1e-10
-            )
-
-    def test_create_slider_config_validation(self):
-        """Test validation for slider configuration creation."""
-        # Mismatched lengths for min/max
-        with self.assertRaises(ValueError):
-            config = create_slider_config([0], [100, 200])
-
-        # Wrong property values length
-        with self.assertRaises(ValueError):
-            config = create_slider_config([0], [100], [25, 50])
-
-    def test_create_slider_config_marks(self):
-        """Test that mark_vals are properly structured dictionaries with interval-based marks."""
-        min_vals = [0, 10]
-        max_vals = [100, 50]
-
-        config = create_slider_config(min_vals, max_vals)
-
-        # Check mark_vals structure
-        self.assertEqual(len(config["mark_vals"]), 2)
-
-        for i, marks in enumerate(config["mark_vals"]):
-            self.assertIsInstance(marks, dict)
-
-            # Check that all mark keys are floats and values are empty strings (no labels)
-            for mark_pos, mark_label in marks.items():
-                self.assertIsInstance(mark_pos, (int, float))
-                self.assertEqual(mark_label, "")  # Empty string, no labels
-                self.assertGreaterEqual(mark_pos, config["min_vals"][i])
-                self.assertLessEqual(mark_pos, config["max_vals"][i])
-
-        # Check that marks follow interval-based logic
-        # First slider: range 0-100 (interval=100.0), should have marks at multiples of 100 within range
-        marks1 = config["mark_vals"][0]
-        # Range 100 gets interval 100.0, so marks should be at 0, 100
-        expected_positions1 = [0.0, 100.0]
-        self.assertEqual(sorted(marks1.keys()), expected_positions1)
-
-        # Second slider: range 10-50 (range=40, interval=10.0), should have marks at multiples of 10 within range
-        marks2 = config["mark_vals"][1]
-        expected_positions2 = [10.0, 20.0, 30.0, 40.0, 50.0]
-        self.assertEqual(sorted(marks2.keys()), expected_positions2)
-
-    def test_snap_to_slider_grid(self):
-        """Test snapping values to slider grid."""
-        # Value already on grid
-        result = snap_to_slider_grid(23.7, 0, 100, 0.1)
-        self.assertAlmostEqual(result, 23.7, places=5)
-
-        # Value between grid points
-        result = snap_to_slider_grid(23.75, 0, 100, 0.1)
-        self.assertAlmostEqual(result, 23.8, places=5)
-
-        # Value below minimum
-        result = snap_to_slider_grid(-10, 0, 100, 1.0)
-        self.assertEqual(result, 0.0)
-
-        # Value above maximum
-        result = snap_to_slider_grid(150, 0, 100, 1.0)
-        self.assertEqual(result, 100.0)
-        # Integer step
-        result = snap_to_slider_grid(23.7, 0, 100, 1.0)
-        self.assertEqual(result, 24.0)
-
-    def test_realistic_scenarios(self):
-        """Test with realistic parameter scenarios."""
-        # Temperature control scenario
-        min_vals = [20, 0, 0.1]
-        max_vals = [100, 50, 10.0]
-        steps = calculate_slider_steps(min_vals, max_vals)
-
-        # Temperature (80°C range) - should have fine control
-        self.assertLessEqual(steps[0], 1.0)
-
-        # Percentage (50% range) - should have reasonable control
-        self.assertLessEqual(steps[1], 1.0)
-
-        # Flow rate (9.9 L/min range) - should have fine control
-        self.assertLessEqual(steps[2], 0.1)
-
-
-if __name__ == "__main__":
-    unittest.main()