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

qnty/codegen/generators/stubs_gen.py

@@ -1,167 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script to generate comprehensive variables.pyi type stub file.
-
-This script generates complete type hints for all 105 variable types in the
-consolidated variables system, providing full IDE autocomplete and type checking
-support for the fluent API with dimension-specific unit properties.
-
-Uses the same source of truth as the consolidated variables system.
-"""
-
-from pathlib import Path
-
-try:
-    from .data_processor import (
-        augment_with_prefixed_units,
-        calculate_statistics,
-        convert_to_class_name,
-        get_dimension_constant_name,
-        load_json_data,
-        save_text_file,
-        setup_import_path,
-    )
-    from .doc_generator import generate_class_docstring, generate_init_method, generate_set_method
-except ImportError:
-    from .data_processor import augment_with_prefixed_units, calculate_statistics, convert_to_class_name, get_dimension_constant_name, load_json_data, save_text_file, setup_import_path
-    from .doc_generator import generate_class_docstring, generate_init_method, generate_set_method
-
-
-
-
-def generate_quantities_pyi(parsed_data: dict, dimension_mapping: dict) -> str:
-    """Generate the variables.pyi type stub content."""
-    
-    lines = [
-        '"""',
-        'Type stubs for quantities module - Complete Edition.',
-        '',
-        'Provides complete type hints for IDE autocomplete and type checking',
-        'for quantity classes and their setter relationships.',
-        f'Contains {len([f for f in parsed_data.values() if f.get("units")])} quantity types with {sum(len(f.get("units", [])) for f in parsed_data.values())} total units.',
-        '',
-        'Auto-generated from unit_data.json.',
-        '"""',
-        '',
-        'from typing import Any',
-        '',
-        'from ..quantities.typed_quantity import TypedQuantity',
-        'from . import dimensions as dim',
-        'from . import setters as ts',
-        ''
-    ]
-    
-    # Generate type stubs for quantity classes only (setters are in separate file)
-    sorted_fields = sorted(parsed_data.items())
-    fields_with_units = [(k, v) for k, v in sorted_fields if v.get('units')]
-    
-    lines.extend([
-        '# ===== QUANTITY CLASSES =====',
-        '# Type stubs for quantity classes with setter relationships',
-        ''
-    ])
-    
-    for field_name, field_data in fields_with_units:
-        class_name = convert_to_class_name(field_name)
-        setter_name = f"{class_name}Setter"
-        display_name = field_data.get('field', class_name).lower()
-        dimension_constant = get_dimension_constant_name(field_name)
-        units = field_data.get('units', [])
-        is_dimensionless = class_name == 'Dimensionless'
-        
-        # Generate quantity class stub
-        lines.append(f'class {class_name}(TypedQuantity):')
-        lines.extend(generate_class_docstring(class_name, display_name, units, is_dimensionless))
-        # Class attributes
-        lines.append('    __slots__ = ()')
-        lines.append(f'    _setter_class = ts.{setter_name}')
-        lines.append(f'    _expected_dimension = dim.{dimension_constant}')
-        lines.append('    ')
-        
-        # Generate __init__ method
-        lines.extend(generate_init_method(class_name, display_name, is_dimensionless, stub_only=True))
-        
-        # Generate set method
-        lines.append('    ')
-        lines.extend(generate_set_method(setter_name, display_name, stub_only=True))
-        lines.append('    ')
-        lines.append('')
-    
-    lines.extend([
-        '# All quantity classes are defined above',
-        '# Setter classes are defined in setters.pyi',
-    ])
-    
-    return '\n'.join(lines) + '\n'
-
-
-def main():
-    """Main execution function."""
-    # Setup import path and import prefixes
-    setup_import_path()
-    
-    # Setup paths using pathlib
-    base_path = Path(__file__).parents[4]  # Go up to qnty root
-    data_path = Path(__file__).parent / "data"
-    output_path = Path(__file__).parent / "out"
-    generated_path = base_path / "src" / "qnty" / "generated"
-    
-    # Ensure output directories exist
-    output_path.mkdir(exist_ok=True)
-    generated_path.mkdir(exist_ok=True)
-    
-    parsed_file = data_path / "unit_data.json"
-    dimension_file = output_path / "dimension_mapping.json"
-    output_file = generated_path / "quantities.pyi"
-    
-    print("Loading parsed units data for type stub generation...")
-    
-    # Load data using shared processor
-    parsed_data = load_json_data(parsed_file)
-    dimension_mapping = load_json_data(dimension_file) if dimension_file.exists() else {}
-    
-    print(f"Loaded {len(parsed_data)} fields with units")
-    
-    # Augment data with missing prefixed units using shared processor
-    print("\nAugmenting data with missing prefixed units...")
-    augmented_data, generated_count = augment_with_prefixed_units(parsed_data)
-    print(f"Generated {generated_count} missing prefixed units for type stubs")
-    
-    # Count fields with units
-    fields_with_units = sum(1 for field_data in augmented_data.values() if field_data.get('units'))
-    print(f"Found {len(augmented_data)} total fields, {fields_with_units} fields with units")
-    
-    # Generate type stub file
-    print("Generating quantities.pyi...")
-    content = generate_quantities_pyi(augmented_data, dimension_mapping)
-    
-    # Write output file
-    save_text_file(content, output_file)
-    print(f"Generated type stub file: {output_file}")
-    
-    # Print statistics using shared calculator
-    stats = calculate_statistics(augmented_data)
-    lines_count = len(content.splitlines())
-    print("\nStatistics:")
-    print(f"  Total fields: {stats['total_fields']}")
-    print(f"  Quantity types: {fields_with_units}")
-    print(f"  Original units: {stats['original_units']}")
-    print(f"  Total units (with prefixes): {stats['total_units']}")
-    print(f"  Generated prefixed units: {stats['generated_prefixed_units']}")
-    print(f"  Generated lines: {lines_count:,}")
-    
-    # Show top quantity types by unit count
-    fields_by_units = [(field_name, len(field_data.get('units', [])), field_data.get('field', ''))
-                       for field_name, field_data in augmented_data.items() if field_data.get('units')]
-    fields_by_units.sort(key=lambda x: x[1], reverse=True)
-    
-    print("\nTop quantity types by unit count:")
-    for field_name, unit_count, display_name in fields_by_units[:10]:
-        class_name = convert_to_class_name(field_name)
-        print(f"  {class_name:<25} : {unit_count:>3} units ({display_name})")
-    
-    print("\nQuantity type stubs generated with full IDE support!")
-
-
-if __name__ == "__main__":
-    main()

qnty/codegen/generators/units_gen.py

@@ -1,295 +0,0 @@
-#!/usr/bin/env python3
-"""
-Units generator for qnty library.
-
-This script generates the units.py file from unit_data.json, creating
-comprehensive unit definitions organized by dimensional groups.
-"""
-
-import json
-from pathlib import Path
-from typing import Any
-
-try:
-    from .data_processor import (
-        augment_with_prefixed_units,
-        convert_to_class_name,
-        escape_string,
-        get_dimension_constant_name,
-        get_unit_names_and_aliases,
-        is_valid_python_identifier,
-        load_unit_data,
-        setup_import_path,
-    )
-except ImportError:
-    from .data_processor import (
-        augment_with_prefixed_units,
-        convert_to_class_name,
-        escape_string,
-        get_dimension_constant_name,
-        get_unit_names_and_aliases,
-        is_valid_python_identifier,
-        load_unit_data,
-        setup_import_path,
-    )
-
-
-class UnitsGenerator:
-    """Generator for units.py file."""
-    
-    def __init__(self, data_path: Path, output_path: Path, out_dir: Path):
-        """Initialize with paths."""
-        self.data_path = data_path
-        self.output_path = output_path
-        self.out_dir = out_dir
-        self.out_dir.mkdir(parents=True, exist_ok=True)
-        
-        # Setup import path and load data
-        setup_import_path()
-        raw_unit_data = load_unit_data(self.data_path)
-        
-        # Augment with prefixed units using shared processor
-        self.unit_data, generated_count = augment_with_prefixed_units(raw_unit_data)
-        print(f"Generated {generated_count} prefixed units")
-        
-        # Track generated info
-        self.dimension_constants: set[str] = set()
-        self.field_to_class_mapping: dict[str, str] = {}
-    
-    
-    def get_class_name(self, field_name: str) -> str:
-        """Convert field name to class name."""
-        # Use shared utility and add 'Units' suffix
-        class_name = convert_to_class_name(field_name) + 'Units'
-        self.field_to_class_mapping[field_name] = class_name
-        return class_name
-    
-    def get_dimension_constant_name(self, field_name: str) -> str:
-        """Get the dimension constant name for a field."""
-        constant_name = get_dimension_constant_name(field_name)
-        self.dimension_constants.add(constant_name)
-        return constant_name
-    
-    
-    def generate_header(self) -> list[str]:
-        """Generate file header with imports."""
-        lines = [
-            '"""',
-            'Comprehensive Units Module',
-            '==========================',
-            '',
-            'Auto-generated unit definitions for all engineering units.',
-            f'Contains {sum(len(field_data["units"]) for field_data in self.unit_data.values())} units',
-            f'across {len(self.unit_data)} fields.',
-            '',
-            'This file is auto-generated by codegen/generators/units_gen.py',
-            'DO NOT EDIT MANUALLY - changes will be overwritten.',
-            '"""',
-            '',
-        ]
-        
-        lines.extend([
-            'from ..units.registry import UnitConstant, UnitDefinition',
-            'from . import dimensions as dim',
-            '',
-            '',
-        ])
-        
-        return lines
-    
-    def generate_unit_class(self, field_name: str, field_data: dict[str, Any]) -> list[str]:
-        """Generate a unit class for a field."""
-        class_name = self.get_class_name(field_name)
-        dimension_constant = self.get_dimension_constant_name(field_name)
-        
-        lines = [
-            f'class {class_name}:',
-            f'    """Unit constants for {field_data["field"]}."""',
-            '    __slots__ = ()',
-            '',
-        ]
-        
-        # Process all units for this field
-        units = field_data.get('units', [])
-        if not units:
-            lines.extend(['    pass', '', ''])
-            return lines
-        
-        # Generate unit constants using shared name processing
-        for unit_data in units:
-            primary_name, aliases = get_unit_names_and_aliases(unit_data)
-            if not is_valid_python_identifier(primary_name):
-                continue
-            
-            full_name = unit_data.get('name', '')
-            symbol = unit_data.get('notation', '')
-            si_factor = unit_data.get('si_conversion', 1.0)
-            
-            lines.extend([
-                f'    # {full_name}',
-                f'    {primary_name} = UnitConstant(UnitDefinition(',
-                f'        name="{escape_string(primary_name)}",',
-                f'        symbol="{escape_string(symbol)}",',
-                f'        dimension=dim.{dimension_constant},',
-                f'        si_factor={si_factor},',
-                '        si_offset=0.0',
-                '    ))',
-                '',
-            ])
-            
-            # Add aliases as class attributes using shared processing
-            for alias in aliases:
-                if is_valid_python_identifier(alias):
-                    lines.append(f'    {alias} = {primary_name}')
-        
-        lines.append('')
-        return lines
-    
-    def generate_registry_function(self) -> list[str]:
-        """Generate function to register all units with registry."""
-        lines = [
-            'def register_all_units(registry) -> None:',
-            '    """Register all unit definitions with the registry."""',
-            '    unit_classes = [',
-        ]
-        
-        # Add all generated unit classes
-        for class_name in sorted(self.field_to_class_mapping.values()):
-            lines.append(f'        {class_name},')
-        
-        lines.extend([
-            '    ]',
-            '',
-            '    for unit_class in unit_classes:',
-            '        for attr_name in dir(unit_class):',
-            '            if not attr_name.startswith("_"):',
-            '                unit_constant = getattr(unit_class, attr_name, None)',
-            '                if unit_constant is not None and hasattr(unit_constant, "definition"):',
-            '                    unit_def = unit_constant.definition',
-            '                    if unit_def.name not in registry.units:',
-            '                        registry.register_unit(unit_def)',
-            '',
-            '    # Finalize registry',
-            '    registry.finalize_registration()',
-            '',
-            '',
-        ])
-        
-        return lines
-    
-    def generate_dimensionless_class(self) -> list[str]:
-        """Generate DimensionlessUnits class for backward compatibility."""
-        return [
-            '# Backward compatibility class',
-            'class DimensionlessUnits:',
-            '    """Dimensionless units for backward compatibility."""',
-            '    __slots__ = ()',
-            '',
-            '    dimensionless = UnitConstant(UnitDefinition(',
-            '        name="dimensionless",',
-            '        symbol="",',
-            '        dimension=dim.DIMENSIONLESS,',
-            '        si_factor=1.0,',
-            '        si_offset=0.0',
-            '    ))',
-            '',
-            '',
-        ]
-    
-    def generate_exports(self) -> list[str]:
-        """Generate __all__ export list."""
-        lines = [
-            '# Export list',
-            '__all__ = [',
-            '    "register_all_units",',
-            '    "DimensionlessUnits",',
-        ]
-        
-        for class_name in sorted(self.field_to_class_mapping.values()):
-            lines.append(f'    "{class_name}",')
-        
-        lines.extend([
-            ']',
-            '',
-        ])
-        
-        return lines
-    
-    def generate_statistics(self) -> list[str]:
-        """Generate statistics section."""
-        total_units = sum(len(field_data.get('units', [])) for field_data in self.unit_data.values())
-        
-        return [
-            '# Statistics',
-            f'TOTAL_UNITS = {total_units}',
-            f'TOTAL_FIELDS = {len(self.unit_data)}',
-            f'TOTAL_DIMENSIONS = {len(self.dimension_constants)}',
-        ]
-    
-    def generate(self) -> None:
-        """Generate the complete units.py file."""
-        # First pass: collect all dimension constants
-        for field_name in self.unit_data.keys():
-            self.get_dimension_constant_name(field_name)
-            self.get_class_name(field_name)
-        
-        # Build file content
-        lines = []
-        lines.extend(self.generate_header())
-        
-        # Generate unit classes for each field
-        for field_name, field_data in sorted(self.unit_data.items()):
-            lines.extend(self.generate_unit_class(field_name, field_data))
-        
-        lines.extend(self.generate_registry_function())
-        lines.extend(self.generate_exports())
-        lines.extend(self.generate_statistics())
-        
-        # Write the file
-        content = '\n'.join(lines) + '\n'
-        self.output_path.write_text(content, encoding='utf-8')
-        print(f"Generated {self.output_path}")
-        
-        # Save metadata
-        metadata = {
-            'total_units': sum(len(field_data.get('units', [])) for field_data in self.unit_data.values()),
-            'total_fields': len(self.unit_data),
-            'total_dimensions': len(self.dimension_constants),
-            'dimension_constants': sorted(self.dimension_constants),
-            'unit_classes': sorted(self.field_to_class_mapping.values()),
-        }
-        
-        metadata_path = self.out_dir / 'units_metadata.json'
-        with open(metadata_path, 'w', encoding='utf-8') as f:
-            json.dump(metadata, f, indent=2)
-        print(f"Saved metadata to {metadata_path}")
-
-
-def main() -> None:
-    """Main entry point."""
-    # Set up paths
-    generator_dir = Path(__file__).parent
-    data_path = generator_dir / 'data' / 'unit_data.json'
-    output_path = generator_dir.parent.parent / 'generated' / 'units.py'
-    out_dir = generator_dir / 'out'
-    
-    # Create output directory if needed
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    
-    # Check if data file exists
-    if not data_path.exists():
-        print(f"Error: Data file not found at {data_path}")
-        return
-    
-    # Run generator
-    generator = UnitsGenerator(data_path, output_path, out_dir)
-    generator.generate()
-    
-    print("\nUnits generation complete!")
-    print(f"  - Total units: {sum(len(field_data.get('units', [])) for field_data in generator.unit_data.values())}")
-    print(f"  - Total fields: {len(generator.unit_data)}")
-    print(f"  - Unit classes: {len(generator.field_to_class_mapping)}")
-
-
-if __name__ == "__main__":
-    main()

qnty/expressions/cache.py

@@ -1,94 +0,0 @@
-"""
-Expression Caching System
-========================
-
-Caching infrastructure for optimized expression evaluation and type checking.
-"""
-
-from typing import TYPE_CHECKING, Union
-
-if TYPE_CHECKING:
-    from ..quantities.quantity import Quantity, TypeSafeVariable
-    from .nodes import Expression
-
-# Import here to avoid circular imports - delayed imports
-from ..generated.units import DimensionlessUnits
-from ..quantities.quantity import Quantity, TypeSafeVariable
-
-# Cache for common types to avoid repeated type checks
-_NUMERIC_TYPES = (int, float)
-_DIMENSIONLESS_CONSTANT = None
-_CACHED_DIMENSIONLESS_QUANTITIES = {}  # Cache for common numeric values
-_MAX_CACHE_SIZE = 50  # Limit cache size to prevent memory bloat
-_TYPE_CHECK_CACHE = {}  # Cache for expensive isinstance checks
-
-# Expression evaluation cache for repeated operations
-_EXPRESSION_RESULT_CACHE = {}
-_MAX_EXPRESSION_CACHE_SIZE = 200
-
-
-def _get_cached_dimensionless():
-    """Get cached dimensionless constant for numeric values."""
-    global _DIMENSIONLESS_CONSTANT
-    if _DIMENSIONLESS_CONSTANT is None:
-        _DIMENSIONLESS_CONSTANT = DimensionlessUnits.dimensionless
-    return _DIMENSIONLESS_CONSTANT
-
-
-def _get_dimensionless_quantity(value: float) -> 'Quantity':
-    """Get cached dimensionless quantity for common numeric values."""
-    if value in _CACHED_DIMENSIONLESS_QUANTITIES:
-        return _CACHED_DIMENSIONLESS_QUANTITIES[value]
-    
-    # Cache common values with size limit
-    if len(_CACHED_DIMENSIONLESS_QUANTITIES) < _MAX_CACHE_SIZE and -10 <= value <= 10:
-        qty = Quantity(value, _get_cached_dimensionless())
-        _CACHED_DIMENSIONLESS_QUANTITIES[value] = qty
-        return qty
-    
-    # Don't cache uncommon values
-    return Quantity(value, _get_cached_dimensionless())
-
-
-def _is_numeric_type(obj) -> bool:
-    """Cached type check for numeric types."""
-    obj_type = type(obj)
-    if obj_type not in _TYPE_CHECK_CACHE:
-        _TYPE_CHECK_CACHE[obj_type] = obj_type in _NUMERIC_TYPES
-    return _TYPE_CHECK_CACHE[obj_type]
-
-
-def wrap_operand(operand: Union['Expression', 'TypeSafeVariable', 'Quantity', int, float]) -> 'Expression':
-    """
-    Optimized operand wrapping with cached type checks.
-    
-    This function uses cached type checks for maximum performance.
-    """
-    # Import Expression classes to avoid circular imports
-    from .nodes import Constant, Expression, VariableReference
-    
-    # Fast path: check most common cases first using cached type check
-    if _is_numeric_type(operand):
-        # operand is guaranteed to be int or float at this point
-        return Constant(_get_dimensionless_quantity(float(operand)))  # type: ignore[arg-type]
-    
-    # Check if already an Expression (using isinstance for speed)
-    if isinstance(operand, Expression):
-        return operand
-    
-    # Check for FastQuantity
-    if isinstance(operand, Quantity):
-        return Constant(operand)
-    
-    # Check for TypeSafeVariable
-    if isinstance(operand, TypeSafeVariable):
-        return VariableReference(operand)
-    
-    # Check for ConfigurableVariable (from composition system)
-    if hasattr(operand, '_variable'):
-        var = getattr(operand, '_variable', None)
-        if isinstance(var, TypeSafeVariable):
-            return VariableReference(var)
-    
-    # No duck typing - fail fast for unknown types
-    raise TypeError(f"Cannot convert {type(operand)} to Expression")