qnty 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

qnty/{prefixes.py → units/prefixes.py}

@@ -10,7 +10,7 @@ from dataclasses import dataclass
 from enum import Enum
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, slots=True)
 class SIPrefix:
     """
     Standard SI prefix definition.
@@ -25,16 +25,12 @@ class SIPrefix:
     factor: float
     
     def apply_to_name(self, base_name: str) -> str:
-        """Apply prefix to a base unit name."""
-        if not self.name:
-            return base_name
-        return f"{self.name}{base_name}"
+        """Apply prefix to a base unit name. Optimized for performance."""
+        return base_name if not self.name else self.name + base_name
     
     def apply_to_symbol(self, base_symbol: str) -> str:
-        """Apply prefix to a base unit symbol."""
-        if not self.symbol:
-            return base_symbol
-        return f"{self.symbol}{base_symbol}"
+        """Apply prefix to a base unit symbol. Optimized for performance."""
+        return base_symbol if not self.symbol else self.symbol + base_symbol
 
 
 class StandardPrefixes(Enum):
@@ -71,8 +67,8 @@ class StandardPrefixes(Enum):
     YOCTO = SIPrefix("yocto", "y", 1e-24)
 
 
-# Common prefix groups for different unit types
-COMMON_LENGTH_PREFIXES = [
+# Common prefix groups for different unit types - type annotated for better IDE support
+COMMON_LENGTH_PREFIXES: list[StandardPrefixes] = [
     StandardPrefixes.KILO,
     StandardPrefixes.CENTI,
     StandardPrefixes.MILLI,
@@ -80,20 +76,20 @@ COMMON_LENGTH_PREFIXES = [
     StandardPrefixes.NANO,
 ]
 
-COMMON_MASS_PREFIXES = [
+COMMON_MASS_PREFIXES: list[StandardPrefixes] = [
     StandardPrefixes.KILO,  # Note: kilogram is the SI base unit
     StandardPrefixes.MILLI,
     StandardPrefixes.MICRO,
 ]
 
-COMMON_TIME_PREFIXES = [
+COMMON_TIME_PREFIXES: list[StandardPrefixes] = [
     StandardPrefixes.MILLI,
     StandardPrefixes.MICRO,
     StandardPrefixes.NANO,
     StandardPrefixes.PICO,
 ]
 
-COMMON_ELECTRIC_PREFIXES = [
+COMMON_ELECTRIC_PREFIXES: list[StandardPrefixes] = [
     StandardPrefixes.KILO,
     StandardPrefixes.MILLI,
     StandardPrefixes.MICRO,
@@ -101,13 +97,13 @@ COMMON_ELECTRIC_PREFIXES = [
     StandardPrefixes.PICO,
 ]
 
-COMMON_ENERGY_PREFIXES = [
+COMMON_ENERGY_PREFIXES: list[StandardPrefixes] = [
     StandardPrefixes.KILO,
     StandardPrefixes.MEGA,
     StandardPrefixes.GIGA,
 ]
 
-COMMON_POWER_PREFIXES = [
+COMMON_POWER_PREFIXES: list[StandardPrefixes] = [
     StandardPrefixes.KILO,
     StandardPrefixes.MEGA,
     StandardPrefixes.GIGA,
@@ -115,39 +111,61 @@ COMMON_POWER_PREFIXES = [
     StandardPrefixes.MICRO,
 ]
 
-COMMON_PRESSURE_PREFIXES = [
+COMMON_PRESSURE_PREFIXES: list[StandardPrefixes] = [
     StandardPrefixes.KILO,
     StandardPrefixes.MEGA,
     StandardPrefixes.GIGA,
 ]
 
 
-def get_prefix_by_name(name: str) -> SIPrefix | None:
-    """Get a prefix by its name (e.g., 'kilo', 'milli')."""
+# Performance optimization: Pre-computed lookup dictionaries
+_NAME_TO_PREFIX: dict[str, SIPrefix] = {}
+_SYMBOL_TO_PREFIX: dict[str, SIPrefix] = {}
+_FACTOR_TO_PREFIX: dict[float, SIPrefix] = {}
+
+def _initialize_lookup_caches():
+    """Initialize lookup caches for O(1) prefix lookups."""
     for prefix_enum in StandardPrefixes:
-        if prefix_enum.value.name == name:
-            return prefix_enum.value
-    return None
+        prefix = prefix_enum.value
+        _NAME_TO_PREFIX[prefix.name] = prefix
+        _SYMBOL_TO_PREFIX[prefix.symbol] = prefix
+        _FACTOR_TO_PREFIX[prefix.factor] = prefix
+
+def get_prefix_by_name(name: str) -> SIPrefix | None:
+    """Get a prefix by its name (e.g., 'kilo', 'milli'). O(1) lookup."""
+    return _NAME_TO_PREFIX.get(name)
 
 
 def get_prefix_by_symbol(symbol: str) -> SIPrefix | None:
-    """Get a prefix by its symbol (e.g., 'k', 'm')."""
-    for prefix_enum in StandardPrefixes:
-        if prefix_enum.value.symbol == symbol:
-            return prefix_enum.value
-    return None
+    """Get a prefix by its symbol (e.g., 'k', 'm'). O(1) lookup."""
+    return _SYMBOL_TO_PREFIX.get(symbol)
 
 
 def get_prefix_by_factor(factor: float, tolerance: float = 1e-10) -> SIPrefix | None:
-    """Get a prefix by its multiplication factor."""
-    for prefix_enum in StandardPrefixes:
-        if abs(prefix_enum.value.factor - factor) < tolerance:
-            return prefix_enum.value
+    """Get a prefix by its multiplication factor. O(1) lookup for exact matches, optimized tolerance search."""
+    # Fast path for exact matches
+    if factor in _FACTOR_TO_PREFIX:
+        return _FACTOR_TO_PREFIX[factor]
+    
+    # Optimized tolerance path - only search if tolerance is meaningful
+    if tolerance > 1e-15:  # Avoid expensive search for tiny tolerances
+        # Use items() view for better performance than .items()
+        for cached_factor, prefix in _FACTOR_TO_PREFIX.items():
+            if abs(cached_factor - factor) < tolerance:
+                return prefix
     return None
 
 
-# Define which units should get automatic prefixes
-PREFIXABLE_UNITS = {
+def extract_prefix_values(prefix_enums: list[StandardPrefixes]) -> list[SIPrefix]:
+    """Extract SIPrefix values from StandardPrefixes enums efficiently.
+    
+    This is optimized for bulk operations that need to convert enum lists to value lists.
+    """
+    return [prefix_enum.value for prefix_enum in prefix_enums]
+
+
+# Define which units should get automatic prefixes - using more descriptive type annotation
+PREFIXABLE_UNITS: dict[str, list[StandardPrefixes]] = {
     # Base SI units
     'meter': COMMON_LENGTH_PREFIXES,
     'gram': COMMON_MASS_PREFIXES,
@@ -227,3 +245,6 @@ PREFIXABLE_UNITS = {
         StandardPrefixes.MICRO
     ],  # Common non-SI unit
 }
+
+# Initialize lookup caches on module load for optimal performance
+_initialize_lookup_caches()

qnty/{unit.py → units/registry.py}

@@ -7,11 +7,11 @@ Unit definitions, constants and registry for the high-performance unit system.
 
 from dataclasses import dataclass
 
-from .dimension import DimensionSignature
+from ..generated.dimensions import DimensionSignature
 from .prefixes import SIPrefix, StandardPrefixes
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, slots=True)
 class UnitDefinition:
     """Immutable unit definition optimized for performance."""
     name: str
@@ -39,58 +39,70 @@ class UnitDefinition:
 class UnitConstant:
     """Unit constant that provides type safety and performance."""
     
+    __slots__ = ('definition', 'name', 'symbol', 'dimension', 'si_factor', '_hash_cache')
+    
     def __init__(self, definition: UnitDefinition):
         self.definition = definition
         self.name = definition.name
         self.symbol = definition.symbol
         self.dimension = definition.dimension
         self.si_factor = definition.si_factor
+        # Cache expensive hash operation
+        self._hash_cache = hash(self.name)
     
     def __str__(self):
         return self.symbol
     
-    def __eq__(self, other):
-        """Fast equality check for unit constants."""
-        return isinstance(other, UnitConstant) and self.name == other.name
+    def __eq__(self, other) -> bool:
+        """Ultra-fast equality check for unit constants."""
+        # Fast path: check type first without isinstance() overhead
+        return type(other) is UnitConstant and self.name == other.name
     
-    def __hash__(self):
-        """Enable unit constants as dictionary keys."""
-        return hash(self.name)
+    def __hash__(self) -> int:
+        """Enable unit constants as dictionary keys with cached hash."""
+        return self._hash_cache
 
 
-class HighPerformanceRegistry:
+class Registry:
     """Ultra-fast registry with pre-computed conversion tables."""
     
+    __slots__ = ('units', 'conversion_table', 'dimensional_groups', '_finalized',
+                 'base_units', 'prefixable_units', '_conversion_cache', '_dimension_cache')
+    
     def __init__(self):
         self.units: dict[str, UnitDefinition] = {}
         self.conversion_table: dict[tuple[str, str], float] = {}  # (from_unit, to_unit) -> factor
         self.dimensional_groups: dict[int | float, list[UnitDefinition]] = {}
-        self._dimension_cache: dict[int | float, UnitConstant] = {}  # Cache for common dimension mappings
         self._finalized = False
         self.base_units: dict[str, UnitDefinition] = {}  # Track base units for prefix generation
         self.prefixable_units: set[str] = set()  # Track which units can have prefixes
+        # Small cache for frequently used conversions to reduce table lookups
+        self._conversion_cache: dict[tuple[str, str], float] = {}
+        # Cache for common dimension mappings (used by variable.py)
+        self._dimension_cache: dict[int | float, UnitConstant] = {}
 
         # Registry starts empty - units are registered via register_all_units() in __init__.py
     
     
-    def register_unit(self, unit_def: UnitDefinition):
+    def register_unit(self, unit_def: UnitDefinition) -> None:
         """Register a single unit definition."""
         if self._finalized:
             raise RuntimeError("Cannot register units after registry is finalized")
             
         self.units[unit_def.name] = unit_def
         
-        # Group by dimension
+        # Group by dimension - optimized to avoid repeated signature access
         dim_sig = unit_def.dimension._signature
-        if dim_sig not in self.dimensional_groups:
-            self.dimensional_groups[dim_sig] = []
-        self.dimensional_groups[dim_sig].append(unit_def)
+        try:
+            self.dimensional_groups[dim_sig].append(unit_def)
+        except KeyError:
+            self.dimensional_groups[dim_sig] = [unit_def]
     
     def register_with_prefixes(
             self,
             unit_def: UnitDefinition,
             prefixes: list[StandardPrefixes] | None = None
-        ):
+        ) -> None:
         """
         Register a unit and automatically generate prefixed variants.
         
@@ -114,36 +126,65 @@ class HighPerformanceRegistry:
                     prefixed_unit = UnitDefinition.with_prefix(unit_def, prefix)
                     self.register_unit(prefixed_unit)
     
-    def finalize_registration(self):
+    def finalize_registration(self) -> None:
         """Called after all units registered to precompute conversions."""
         if not self._finalized:
             self._precompute_conversions()
             self._finalized = True
 
-    def _precompute_conversions(self):
-        """Pre-compute all unit conversions for maximum speed."""
+    def _precompute_conversions(self) -> None:
+        """Pre-compute all unit conversions for maximum speed with optimized algorithms."""
         self.conversion_table.clear()  # Clear existing conversions
+        self._conversion_cache.clear()  # Clear cache
+        
         for group in self.dimensional_groups.values():
-            for from_unit in group:
-                for to_unit in group:
-                    if from_unit != to_unit:
-                        factor = from_unit.si_factor / to_unit.si_factor
-                        key = (from_unit.name, to_unit.name)
-                        self.conversion_table[key] = factor
+            group_size = len(group)
+            if group_size <= 1:
+                continue  # Skip groups with single units
+            
+            # Ultra-optimized: pre-compute all factors and names in single pass
+            unit_data = [(unit.name, unit.si_factor) for unit in group]
+            
+            # Vectorized approach: compute all combinations efficiently
+            for i in range(group_size):
+                from_name, from_si = unit_data[i]
+                for j in range(group_size):
+                    if i != j:  # Skip same unit conversion
+                        to_name, to_si = unit_data[j]
+                        # Pre-compute factor - avoid repeated division
+                        factor = from_si / to_si
+                        self.conversion_table[(from_name, to_name)] = factor
     
     def convert(self, value: float, from_unit: UnitConstant, to_unit: UnitConstant) -> float:
-        """Ultra-fast conversion using pre-computed table."""
-        if from_unit == to_unit:
+        """Ultra-fast conversion with optimized equality check and caching."""
+        # Ultra-fast path: avoid expensive equality check by comparing names directly
+        if from_unit.name == to_unit.name:
             return value
         
-        # O(1) lookup for pre-computed conversions
         key = (from_unit.name, to_unit.name)
-        if key in self.conversion_table:
-            return value * self.conversion_table[key]
+        
+        # Check small cache first for frequently used conversions
+        try:
+            return value * self._conversion_cache[key]
+        except KeyError:
+            pass
+        
+        # O(1) lookup for pre-computed conversions
+        try:
+            factor = self.conversion_table[key]
+            # Cache frequently used conversions (keep cache small)
+            if len(self._conversion_cache) < 50:
+                self._conversion_cache[key] = factor
+            return value * factor
+        except KeyError:
+            pass
         
         # Fallback (shouldn't happen for registered units)
-        return value * from_unit.si_factor / to_unit.si_factor
+        factor = from_unit.si_factor / to_unit.si_factor
+        if len(self._conversion_cache) < 50:
+            self._conversion_cache[key] = factor
+        return value * factor
 
 
 # Global high-performance registry
-registry = HighPerformanceRegistry()
+registry = Registry()

qnty/utils/logging.py

@@ -0,0 +1,40 @@
+import logging
+import os
+
+_LOGGER: logging.Logger | None = None
+
+
+def get_logger(name: str = "optinova") -> logging.Logger:
+    """Return a module-level configured logger.
+
+    Log level resolves in order:
+    1. Explicit environment variable OPTINOVA_LOG_LEVEL
+    2. Existing logger level if already configured
+    3. Defaults to INFO
+    """
+    global _LOGGER
+    if _LOGGER is not None:
+        return _LOGGER
+
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        # Basic handler (stdout)
+        handler = logging.StreamHandler()
+        fmt = os.getenv("OPTINOVA_LOG_FORMAT", "%(asctime)s | %(levelname)s | %(name)s | %(message)s")
+        handler.setFormatter(logging.Formatter(fmt))
+        logger.addHandler(handler)
+
+    # Resolve level
+    level_str = os.getenv("OPTINOVA_LOG_LEVEL", "INFO").upper()
+    level = getattr(logging, level_str, logging.INFO)
+    logger.setLevel(level)
+    logger.propagate = False
+
+    _LOGGER = logger
+    return logger
+
+
+def set_log_level(level: str):
+    """Dynamically adjust log level at runtime."""
+    logger = get_logger()
+    logger.setLevel(getattr(logging, level.upper(), logging.INFO))

qnty/validation/rules.py

@@ -0,0 +1,167 @@
+"""
+Engineering problem checks and validation system.
+
+This module provides a clean API for defining engineering code compliance checks,
+warnings, and validation rules at the problem level rather than variable level.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Literal
+
+from qnty.expressions import Expression as QntyExpression
+
+
+@dataclass
+class Rules:
+    """
+    Represents an engineering problem check (code compliance, validation, etc.).
+    
+    Checks are defined at the EngineeringProblem class level and evaluated after solving.
+    They can represent code compliance rules, engineering judgment warnings, or
+    validation conditions.
+    """
+    condition: QntyExpression
+    message: str
+    warning_type: str = "VALIDATION"
+    severity: Literal["INFO", "WARNING", "ERROR"] = "WARNING"
+    name: str | None = None
+    
+    def __post_init__(self):
+        """Generate a name if not provided."""
+        if self.name is None:
+            self.name = f"{self.warning_type}_{self.severity}"
+    
+    def evaluate(self, variables: dict[str, Any]) -> dict[str, Any] | None:
+        """
+        Evaluate the check condition and return a warning dict if condition is True.
+        
+        Args:
+            variables: Dictionary of variable name -> variable object mappings
+            
+        Returns:
+            Warning dictionary if condition is met, None otherwise
+        """
+        try:
+            # Evaluate the condition expression using qnty's evaluation system
+            result = self._evaluate_expression(self.condition, variables)
+            
+            if result:
+                return {
+                    "type": self.warning_type,
+                    "severity": self.severity,
+                    "message": self.message,
+                    "check_name": self.name,
+                    "condition": str(self.condition)
+                }
+                
+        except Exception as e:
+            # If evaluation fails, return an error warning
+            import traceback
+            return {
+                "type": "EVALUATION_ERROR",
+                "severity": "ERROR",
+                "message": f"Failed to evaluate check '{self.name}': {str(e)}",
+                "check_name": self.name,
+                "condition": str(self.condition),
+                "debug_info": f"Expression type: {type(self.condition)}, Variables: {list(variables.keys())}",
+                "traceback": traceback.format_exc()
+            }
+        
+        return None
+    
+    def _evaluate_expression(self, expr: QntyExpression, variables: dict[str, Any]) -> bool:
+        """
+        Evaluate a qnty expression with current variable values.
+        
+        For qnty expressions, we can evaluate them directly since they have
+        references to the variable values.
+        """
+        try:
+            # qnty expressions have an evaluate() method that needs variable values
+            if hasattr(expr, 'evaluate'):
+                # Create a variable_values dict with the variable objects, not their quantities
+                var_values = {}
+                for var_name, var_obj in variables.items():
+                    var_values[var_name] = var_obj
+                
+                result = expr.evaluate(var_values)
+                # For boolean comparisons, result should be 1.0 (True) or 0.0 (False)
+                # Handle FastQuantity type
+                if hasattr(result, 'value'):  # FastQuantity
+                    return bool(result.value > 0.5)
+                elif hasattr(result, '__float__'):
+                    # Use type: ignore to handle FastQuantity/Expression types that don't have __float__
+                    return bool(float(result) > 0.5)  # type: ignore[arg-type]
+                else:
+                    # Last resort - try str conversion then float
+                    result_str = str(result)
+                    # Handle cases like "0.0 " (with units)
+                    try:
+                        return bool(float(result_str.split()[0]) > 0.5)
+                    except (ValueError, IndexError):
+                        return False
+            else:
+                # Try direct conversion as fallback
+                if hasattr(expr, '__float__'):
+                    # Use type: ignore to handle Expression types that don't have __float__
+                    return bool(float(expr) > 0.5)  # type: ignore[arg-type]
+                else:
+                    return bool(float(str(expr)) > 0.5)
+        except Exception as e:
+            # If evaluation fails, assume the condition is not met
+            # Re-raise to get better debugging info
+            raise e
+
+
+def add_rule(
+    condition: QntyExpression,
+    message: str,
+    warning_type: str = "VALIDATION",
+    severity: Literal["INFO", "WARNING", "ERROR"] = "WARNING",
+    name: str | None = None
+) -> Rules:
+    """
+    Create a new engineering problem check.
+    
+    This function is intended to be called at the class level when defining
+    EngineeringProblem subclasses. It creates Check objects that will be
+    automatically collected by the metaclass.
+    
+    Args:
+        condition: A qnty Expression that evaluates to True when the check should trigger
+        message: Descriptive message explaining what the check means
+        warning_type: Category of check (e.g., "CODE_COMPLIANCE", "VALIDATION")
+        severity: Severity level of the check
+        name: Optional name for the check
+        
+    Returns:
+        Check object that can be assigned to a class attribute
+        
+    Example:
+        class MyProblem(EngineeringProblem):
+            # Variables...
+            P = Pressure(90, "psi")
+            t = Length(0.1, "inch")
+            D = Length(1.0, "inch")
+            
+            # Checks defined at class level
+            thick_wall_check = add_check(
+                t.geq(D / 6),
+                "Thick wall condition detected - requires special consideration",
+                warning_type="CODE_COMPLIANCE",
+                severity="WARNING"
+            )
+    """
+    return Rules(
+        condition=condition,
+        message=message,
+        warning_type=warning_type,
+        severity=severity,
+        name=name
+    )
+
+__all__ = [
+    "add_rule"
+]