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

qnty/codegen/generators/stubs_gen.py

@@ -0,0 +1,167 @@
+#!/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

@@ -0,0 +1,295 @@
+#!/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/equations/__init__.py

@@ -0,0 +1,4 @@
+from .equation import Equation
+from .system import EquationSystem
+
+__all__ = ['Equation', 'EquationSystem']