qnty 0.1.4__tar.gz → 0.1.5__tar.gz

{qnty-0.1.4 → qnty-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qnty
-Version: 0.1.4
+Version: 0.1.5
 Summary: High-performance unit system library for Python with dimensional safety and fast unit conversions
 License: Apache-2.0
 Keywords: units,dimensional analysis,engineering,physics,quantities,measurements

{qnty-0.1.4 → qnty-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qnty"
-version = "0.1.4"
+version = "0.1.5"
 description = "High-performance unit system library for Python with dimensional safety and fast unit conversions"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{qnty-0.1.4 → qnty-0.1.5}/src/qnty/expressions/functions.py

@@ -16,8 +16,24 @@ ConditionalOperand = Expression | BinaryOperation
 def _create_unary_function(name: str, docstring: str):
     """Factory function for creating unary mathematical functions."""
 
-    def func(expr: ExpressionOperand) -> UnaryFunction:
-        return UnaryFunction(name, wrap_operand(expr))
+    def func(expr: ExpressionOperand):
+        from .nodes import VariableReference
+        
+        wrapped_expr = wrap_operand(expr)
+        
+        # For known quantities (FieldQnty with known values), evaluate immediately
+        if hasattr(expr, 'quantity') and expr.quantity is not None:
+            try:
+                unary_func = UnaryFunction(name, wrapped_expr)
+                # Use an empty variable dict since we have the quantity directly
+                result = unary_func.evaluate({})
+                return result
+            except (ValueError, TypeError, AttributeError):
+                # Fall back to expression if evaluation fails
+                pass
+        
+        # For unknown variables or expressions, return the UnaryFunction
+        return UnaryFunction(name, wrapped_expr)
 
     func.__name__ = name
     func.__doc__ = docstring

{qnty-0.1.4 → qnty-0.1.5}/src/qnty/expressions/nodes.py

@@ -514,14 +514,14 @@ class UnaryFunction(Expression):
 
         # Function dispatch table for better performance and maintainability
         functions = {
-            "sin": lambda x: Quantity(math.sin(x.value), DimensionlessUnits.dimensionless),
-            "cos": lambda x: Quantity(math.cos(x.value), DimensionlessUnits.dimensionless),
-            "tan": lambda x: Quantity(math.tan(x.value), DimensionlessUnits.dimensionless),
+            "sin": lambda x: math.sin(self._to_radians_if_angle(x)),
+            "cos": lambda x: math.cos(self._to_radians_if_angle(x)),
+            "tan": lambda x: math.tan(self._to_radians_if_angle(x)),
             "sqrt": lambda x: Quantity(math.sqrt(x.value), x.unit),
             "abs": lambda x: Quantity(abs(x.value), x.unit),
-            "ln": lambda x: Quantity(math.log(x.value), DimensionlessUnits.dimensionless),
-            "log10": lambda x: Quantity(math.log10(x.value), DimensionlessUnits.dimensionless),
-            "exp": lambda x: Quantity(math.exp(x.value), DimensionlessUnits.dimensionless),
+            "ln": lambda x: math.log(x.value),
+            "log10": lambda x: math.log10(x.value),
+            "exp": lambda x: math.exp(x.value),
         }
 
         func = functions.get(self.function_name)
@@ -530,6 +530,35 @@ class UnaryFunction(Expression):
         else:
             raise ValueError(f"Unknown function: {self.function_name}")
 
+    def _to_radians_if_angle(self, quantity: "Quantity") -> float:
+        """Convert angle quantities to radians for trigonometric functions."""
+        from ..dimensions import field_dims
+        
+        # Check if this is an angle dimension by comparing dimension signature
+        # Need to handle the case where angle dimensions might not exactly match due to implementation details
+        try:
+            # Import angle plane dimension for comparison
+            angle_plane_dim = field_dims.ANGLE_PLANE
+            
+            # If this looks like an angle (has angle dimension or unit name suggests it)
+            if (hasattr(quantity, '_dimension_sig') and quantity._dimension_sig == angle_plane_dim) or \
+               (hasattr(quantity, 'unit') and hasattr(quantity.unit, 'name') and 
+                any(angle_word in str(quantity.unit.name).lower() for angle_word in ['degree', 'radian', 'grad', 'gon'])):
+                
+                # Import the radian unit for conversion
+                from ..units.field_units import AnglePlaneUnits
+                
+                # Convert to radians and return the numeric value
+                radian_quantity = quantity.to(AnglePlaneUnits.radian.definition)
+                return radian_quantity.value
+            else:
+                # Non-angle quantities: return raw value (backward compatibility)
+                return quantity.value
+        except (ImportError, AttributeError, ValueError):
+            # If anything goes wrong with angle detection/conversion, fall back to raw value
+            return quantity.value
+
+
     def get_variables(self) -> set[str]:
         return self.operand.get_variables()
 
@@ -546,6 +575,15 @@ class UnaryFunction(Expression):
         return UnaryFunction(self.function_name, simplified_operand)
 
     def __str__(self) -> str:
+        # Try auto-evaluation first if possible
+        can_eval, variables = self._can_auto_evaluate()
+        if can_eval and variables:
+            try:
+                result = self.evaluate(variables)
+                return str(result)
+            except (ValueError, TypeError, AttributeError):
+                # Fall back to symbolic representation
+                pass
         return ExpressionFormatter.format_unary_function(self)  # type: ignore[arg-type]
 
 

{qnty-0.1.4 → qnty-0.1.5}/src/qnty/problems/composition.py

@@ -186,6 +186,8 @@ class ConfigurableVariable:
                 return self._variable._arithmetic_mode
             # Otherwise default to 'expression'
             return 'expression'
+        
+        
         return getattr(self._variable, name)
 
     # Delegate arithmetic operations to the wrapped variable
@@ -233,10 +235,10 @@ class ConfigurableVariable:
     def __ge__(self, other):
         return self._variable.__ge__(other)
 
-    def __eq__(self, other):
+    def __eq__(self, other):  # type: ignore[override]
         return self._variable.__eq__(other)
 
-    def __ne__(self, other):
+    def __ne__(self, other):  # type: ignore[override]
         return self._variable.__ne__(other)
 
     def __setattr__(self, name, value):
@@ -257,6 +259,30 @@ class ConfigurableVariable:
         else:
             return original_setter
 
+    def update(self, value=None, unit=None, quantity=None, is_known=None):
+        """Override update method to track configuration changes."""
+        result = self._variable.update(value, unit, quantity, is_known)
+        if self._proxy and self._original_symbol:
+            # Track this configuration change
+            self._proxy.track_configuration(self._original_symbol, self._variable.quantity, self._variable.is_known)
+        return result
+
+    def mark_known(self):
+        """Override mark_known to track configuration changes."""
+        result = self._variable.mark_known()
+        if self._proxy and self._original_symbol:
+            # Track this configuration change
+            self._proxy.track_configuration(self._original_symbol, self._variable.quantity, self._variable.is_known)
+        return result
+
+    def mark_unknown(self):
+        """Override mark_unknown to track configuration changes."""
+        result = self._variable.mark_unknown()
+        if self._proxy and self._original_symbol:
+            # Track this configuration change
+            self._proxy.track_configuration(self._original_symbol, self._variable.quantity, self._variable.is_known)
+        return result
+
 
 class TrackingSetterWrapper:
     """
@@ -307,30 +333,6 @@ class TrackingSetterWrapper:
             )
         return result
 
-    def update(self, value=None, unit=None, quantity=None, is_known=None):
-        """Override update method to track configuration changes."""
-        result = self._variable.update(value, unit, quantity, is_known)
-        if self._proxy and self._original_symbol:
-            # Track this configuration change
-            self._proxy.track_configuration(self._original_symbol, self._variable.quantity, self._variable.is_known)
-        return result
-
-    def mark_known(self):
-        """Override mark_known to track configuration changes."""
-        result = self._variable.mark_known()
-        if self._proxy and self._original_symbol:
-            # Track this configuration change
-            self._proxy.track_configuration(self._original_symbol, self._variable.quantity, self._variable.is_known)
-        return result
-
-    def mark_unknown(self):
-        """Override mark_unknown to track configuration changes."""
-        result = self._variable.mark_unknown()
-        if self._proxy and self._original_symbol:
-            # Track this configuration change
-            self._proxy.track_configuration(self._original_symbol, self._variable.quantity, self._variable.is_known)
-        return result
-
 
 class DelayedVariableReference(ArithmeticOperationsMixin):
     """

{qnty-0.1.4 → qnty-0.1.5}/src/qnty/units/field_units.py

@@ -248,7 +248,7 @@ class AnglePlaneUnits:
         name="degree",
         symbol="${ }^{\\circ}$",
         dimension=dim.ANGLE_PLANE,
-        si_factor=0.0174533,
+        si_factor=0.017453292519943295,
         si_offset=0.0,
     ))