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

qnty/codegen/generators/out/dimension_metadata.json

@@ -0,0 +1,123 @@
+{
+  "total_dimensions": 110,
+  "generated_dimensions": [
+    "absorbed_dose",
+    "acceleration",
+    "activation_energy",
+    "amount_of_substance",
+    "angle_plane",
+    "angle_solid",
+    "angular_acceleration",
+    "angular_momentum",
+    "area",
+    "area_per_unit_volume",
+    "atomic_weight",
+    "concentration",
+    "dimensionless",
+    "dynamic_fluidity",
+    "electric_capacitance",
+    "electric_charge",
+    "electric_current_intensity",
+    "electric_dipole_moment",
+    "electric_field_strength",
+    "electric_inductance",
+    "electric_potential",
+    "electric_resistance",
+    "electrical_conductance",
+    "electrical_permittivity",
+    "electrical_resistivity",
+    "energy_flux",
+    "energy_heat_work",
+    "energy_per_unit_area",
+    "force",
+    "force_body",
+    "force_per_unit_mass",
+    "frequency_voltage_ratio",
+    "fuel_consumption",
+    "heat_of_combustion",
+    "heat_of_fusion",
+    "heat_of_vaporization",
+    "heat_transfer_coefficient",
+    "illuminance",
+    "kinetic_energy_of_turbulence",
+    "length",
+    "linear_mass_density",
+    "linear_momentum",
+    "luminance_self",
+    "luminous_flux",
+    "luminous_intensity",
+    "magnetic_field",
+    "magnetic_flux",
+    "magnetic_induction_field_strength",
+    "magnetic_moment",
+    "magnetic_permeability",
+    "magnetomotive_force",
+    "mass",
+    "mass_density",
+    "mass_flow_rate",
+    "mass_flux",
+    "mass_fraction_of_i",
+    "mass_transfer_coefficient",
+    "molality_of_solute_i",
+    "molar_concentration_by_mass",
+    "molar_flow_rate",
+    "molar_flux",
+    "molar_heat_capacity",
+    "molarity_of_i",
+    "mole_fraction_of_i",
+    "moment_of_inertia",
+    "momentum_flow_rate",
+    "momentum_flux",
+    "normality_of_solution",
+    "particle_density",
+    "percent",
+    "permeability",
+    "photon_emission_rate",
+    "power_per_unit_mass",
+    "power_per_unit_volume",
+    "power_thermal_duty",
+    "pressure",
+    "radiation_dose_equivalent",
+    "radiation_exposure",
+    "radioactivity",
+    "second_moment_of_area",
+    "second_radiation_constant_planck",
+    "specific_enthalpy",
+    "specific_gravity",
+    "specific_heat_capacity_constant_pressure",
+    "specific_length",
+    "specific_surface",
+    "specific_volume",
+    "stress",
+    "surface_mass_density",
+    "surface_tension",
+    "temperature",
+    "thermal_conductivity",
+    "time",
+    "torque",
+    "turbulence_energy_dissipation_rate",
+    "velocity_angular",
+    "velocity_linear",
+    "viscosity_dynamic",
+    "viscosity_kinematic",
+    "volume",
+    "volume_fraction_of_i",
+    "volumetric_calorific_heating_value",
+    "volumetric_coefficient_of_expansion",
+    "volumetric_flow_rate",
+    "volumetric_flux",
+    "volumetric_mass_flow_rate",
+    "wavenumber"
+  ],
+  "base_dimensions": [
+    "LENGTH",
+    "MASS",
+    "TIME",
+    "CURRENT",
+    "TEMPERATURE",
+    "AMOUNT",
+    "LUMINOSITY",
+    "DIMENSIONLESS"
+  ],
+  "signatures_cached": 73
+}

qnty/codegen/generators/out/units_metadata.json

@@ -0,0 +1,223 @@
+{
+  "total_units": 871,
+  "total_fields": 107,
+  "total_dimensions": 107,
+  "dimension_constants": [
+    "ABSORBED_DOSE",
+    "ACCELERATION",
+    "ACTIVATION_ENERGY",
+    "AMOUNT_OF_SUBSTANCE",
+    "ANGLE_PLANE",
+    "ANGLE_SOLID",
+    "ANGULAR_ACCELERATION",
+    "ANGULAR_MOMENTUM",
+    "AREA",
+    "AREA_PER_UNIT_VOLUME",
+    "ATOMIC_WEIGHT",
+    "CONCENTRATION",
+    "DIMENSIONLESS",
+    "DYNAMIC_FLUIDITY",
+    "ELECTRICAL_CONDUCTANCE",
+    "ELECTRICAL_PERMITTIVITY",
+    "ELECTRICAL_RESISTIVITY",
+    "ELECTRIC_CAPACITANCE",
+    "ELECTRIC_CHARGE",
+    "ELECTRIC_CURRENT_INTENSITY",
+    "ELECTRIC_DIPOLE_MOMENT",
+    "ELECTRIC_FIELD_STRENGTH",
+    "ELECTRIC_INDUCTANCE",
+    "ELECTRIC_POTENTIAL",
+    "ELECTRIC_RESISTANCE",
+    "ENERGY_FLUX",
+    "ENERGY_HEAT_WORK",
+    "ENERGY_PER_UNIT_AREA",
+    "FORCE",
+    "FORCE_BODY",
+    "FORCE_PER_UNIT_MASS",
+    "FREQUENCY_VOLTAGE_RATIO",
+    "FUEL_CONSUMPTION",
+    "HEAT_OF_COMBUSTION",
+    "HEAT_OF_FUSION",
+    "HEAT_OF_VAPORIZATION",
+    "HEAT_TRANSFER_COEFFICIENT",
+    "ILLUMINANCE",
+    "KINETIC_ENERGY_OF_TURBULENCE",
+    "LENGTH",
+    "LINEAR_MASS_DENSITY",
+    "LINEAR_MOMENTUM",
+    "LUMINANCE_SELF",
+    "LUMINOUS_FLUX",
+    "LUMINOUS_INTENSITY",
+    "MAGNETIC_FIELD",
+    "MAGNETIC_FLUX",
+    "MAGNETIC_INDUCTION_FIELD_STRENGTH",
+    "MAGNETIC_MOMENT",
+    "MAGNETIC_PERMEABILITY",
+    "MAGNETOMOTIVE_FORCE",
+    "MASS",
+    "MASS_DENSITY",
+    "MASS_FLOW_RATE",
+    "MASS_FLUX",
+    "MASS_FRACTION_OF_I",
+    "MASS_TRANSFER_COEFFICIENT",
+    "MOLALITY_OF_SOLUTE_I",
+    "MOLARITY_OF_I",
+    "MOLAR_CONCENTRATION_BY_MASS",
+    "MOLAR_FLOW_RATE",
+    "MOLAR_FLUX",
+    "MOLAR_HEAT_CAPACITY",
+    "MOLE_FRACTION_OF_I",
+    "MOMENTUM_FLOW_RATE",
+    "MOMENTUM_FLUX",
+    "MOMENT_OF_INERTIA",
+    "NORMALITY_OF_SOLUTION",
+    "PARTICLE_DENSITY",
+    "PERCENT",
+    "PERMEABILITY",
+    "PHOTON_EMISSION_RATE",
+    "POWER_PER_UNIT_MASS",
+    "POWER_PER_UNIT_VOLUME",
+    "POWER_THERMAL_DUTY",
+    "PRESSURE",
+    "RADIATION_DOSE_EQUIVALENT",
+    "RADIATION_EXPOSURE",
+    "RADIOACTIVITY",
+    "SECOND_MOMENT_OF_AREA",
+    "SECOND_RADIATION_CONSTANT_PLANCK",
+    "SPECIFIC_ENTHALPY",
+    "SPECIFIC_GRAVITY",
+    "SPECIFIC_HEAT_CAPACITY_CONSTANT_PRESSURE",
+    "SPECIFIC_LENGTH",
+    "SPECIFIC_SURFACE",
+    "SPECIFIC_VOLUME",
+    "STRESS",
+    "SURFACE_MASS_DENSITY",
+    "SURFACE_TENSION",
+    "TEMPERATURE",
+    "THERMAL_CONDUCTIVITY",
+    "TIME",
+    "TORQUE",
+    "TURBULENCE_ENERGY_DISSIPATION_RATE",
+    "VELOCITY_ANGULAR",
+    "VELOCITY_LINEAR",
+    "VISCOSITY_DYNAMIC",
+    "VISCOSITY_KINEMATIC",
+    "VOLUME",
+    "VOLUMETRIC_CALORIFIC_HEATING_VALUE",
+    "VOLUMETRIC_COEFFICIENT_OF_EXPANSION",
+    "VOLUMETRIC_FLOW_RATE",
+    "VOLUMETRIC_FLUX",
+    "VOLUMETRIC_MASS_FLOW_RATE",
+    "VOLUME_FRACTION_OF_I",
+    "WAVENUMBER"
+  ],
+  "unit_classes": [
+    "AbsorbedDoseUnits",
+    "AccelerationUnits",
+    "ActivationEnergyUnits",
+    "AmountOfSubstanceUnits",
+    "AnglePlaneUnits",
+    "AngleSolidUnits",
+    "AngularAccelerationUnits",
+    "AngularMomentumUnits",
+    "AreaPerUnitVolumeUnits",
+    "AreaUnits",
+    "AtomicWeightUnits",
+    "ConcentrationUnits",
+    "DimensionlessUnits",
+    "DynamicFluidityUnits",
+    "ElectricCapacitanceUnits",
+    "ElectricChargeUnits",
+    "ElectricCurrentIntensityUnits",
+    "ElectricDipoleMomentUnits",
+    "ElectricFieldStrengthUnits",
+    "ElectricInductanceUnits",
+    "ElectricPotentialUnits",
+    "ElectricResistanceUnits",
+    "ElectricalConductanceUnits",
+    "ElectricalPermittivityUnits",
+    "ElectricalResistivityUnits",
+    "EnergyFluxUnits",
+    "EnergyHeatWorkUnits",
+    "EnergyPerUnitAreaUnits",
+    "ForceBodyUnits",
+    "ForcePerUnitMassUnits",
+    "ForceUnits",
+    "FrequencyVoltageRatioUnits",
+    "FuelConsumptionUnits",
+    "HeatOfCombustionUnits",
+    "HeatOfFusionUnits",
+    "HeatOfVaporizationUnits",
+    "HeatTransferCoefficientUnits",
+    "IlluminanceUnits",
+    "KineticEnergyOfTurbulenceUnits",
+    "LengthUnits",
+    "LinearMassDensityUnits",
+    "LinearMomentumUnits",
+    "LuminanceSelfUnits",
+    "LuminousFluxUnits",
+    "LuminousIntensityUnits",
+    "MagneticFieldUnits",
+    "MagneticFluxUnits",
+    "MagneticInductionFieldStrengthUnits",
+    "MagneticMomentUnits",
+    "MagneticPermeabilityUnits",
+    "MagnetomotiveForceUnits",
+    "MassDensityUnits",
+    "MassFlowRateUnits",
+    "MassFluxUnits",
+    "MassFractionOfIUnits",
+    "MassTransferCoefficientUnits",
+    "MassUnits",
+    "MolalityOfSoluteIUnits",
+    "MolarConcentrationByMassUnits",
+    "MolarFlowRateUnits",
+    "MolarFluxUnits",
+    "MolarHeatCapacityUnits",
+    "MolarityOfIUnits",
+    "MoleFractionOfIUnits",
+    "MomentOfInertiaUnits",
+    "MomentumFlowRateUnits",
+    "MomentumFluxUnits",
+    "NormalityOfSolutionUnits",
+    "ParticleDensityUnits",
+    "PercentUnits",
+    "PermeabilityUnits",
+    "PhotonEmissionRateUnits",
+    "PowerPerUnitMassUnits",
+    "PowerPerUnitVolumeUnits",
+    "PowerThermalDutyUnits",
+    "PressureUnits",
+    "RadiationDoseEquivalentUnits",
+    "RadiationExposureUnits",
+    "RadioactivityUnits",
+    "SecondMomentOfAreaUnits",
+    "SecondRadiationConstantPlanckUnits",
+    "SpecificEnthalpyUnits",
+    "SpecificGravityUnits",
+    "SpecificHeatCapacityConstantPressureUnits",
+    "SpecificLengthUnits",
+    "SpecificSurfaceUnits",
+    "SpecificVolumeUnits",
+    "StressUnits",
+    "SurfaceMassDensityUnits",
+    "SurfaceTensionUnits",
+    "TemperatureUnits",
+    "ThermalConductivityUnits",
+    "TimeUnits",
+    "TorqueUnits",
+    "TurbulenceEnergyDissipationRateUnits",
+    "VelocityAngularUnits",
+    "VelocityLinearUnits",
+    "ViscosityDynamicUnits",
+    "ViscosityKinematicUnits",
+    "VolumeFractionOfIUnits",
+    "VolumeUnits",
+    "VolumetricCalorificHeatingValueUnits",
+    "VolumetricCoefficientOfExpansionUnits",
+    "VolumetricFlowRateUnits",
+    "VolumetricFluxUnits",
+    "VolumetricMassFlowRateUnits",
+    "WavenumberUnits"
+  ]
+}

qnty/codegen/generators/quantities_gen.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""
+Script to generate comprehensive quantities.py for all variable types.
+
+This script generates static quantity class definitions without setter classes.
+The setter classes are generated separately in setters_gen.py.
+"""
+
+from pathlib import Path
+
+try:
+    from .data_processor import (
+        augment_with_prefixed_units,
+        calculate_statistics,
+        convert_to_class_name,
+        get_dimension_constant_name,
+        load_unit_data,
+        save_text_file,
+        setup_import_path,
+    )
+    from .doc_generator import generate_class_docstring, generate_init_method, generate_set_method
+except ImportError:
+    # Handle standalone execution
+    import sys
+    from pathlib import Path
+    sys.path.insert(0, str(Path(__file__).parent))
+    from .data_processor import (
+        augment_with_prefixed_units,
+        calculate_statistics,
+        convert_to_class_name,
+        get_dimension_constant_name,
+        load_unit_data,
+        save_text_file,
+        setup_import_path,
+    )
+    from .doc_generator import generate_class_docstring, generate_init_method, generate_set_method
+
+
+def generate_quantities(parsed_data: dict, dimension_mapping: dict) -> str:
+    """Generate the quantities.py content with static class definitions for performance."""
+    del dimension_mapping  # Unused but kept for API compatibility
+    
+    sorted_fields = sorted(parsed_data.items())
+    fields_with_units = [(k, v) for k, v in sorted_fields if v.get('units')]
+    
+    lines = [
+        '"""',
+        'Quantity Classes Module - Static Edition',
+        '========================================',
+        '',
+        'Static quantity class definitions for maximum import performance.',
+        'Uses static class generation instead of dynamic type() calls.',
+        'Auto-generated from unit_data.json.',
+        '"""',
+        '',
+        'from ..quantities.typed_quantity import TypedQuantity',
+        'from . import dimensions as dim',
+        'from . import setters as ts',
+        ''
+    ]
+    
+    # Generate all quantity classes
+    lines.append('# ===== QUANTITY CLASSES =====')
+    lines.append('# Static quantity class definitions with __slots__ optimization')
+    lines.append('')
+    
+    for field_name, field_data in fields_with_units:
+        class_name = convert_to_class_name(field_name)
+        setter_class_name = f"{class_name}Setter"
+        dimension_constant = get_dimension_constant_name(field_name)
+        display_name = field_data.get('field', class_name).lower()
+        units = field_data.get('units', [])
+        is_dimensionless = class_name == 'Dimensionless'
+        
+        # Generate class declaration and docstring
+        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_class_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=False))
+        
+        # Generate set method
+        lines.append('    ')
+        lines.extend(generate_set_method(setter_class_name, display_name, stub_only=False))
+        lines.append('    ')
+        lines.append('')
+    
+    return '\n'.join(lines) + '\n'
+
+
+def main():
+    """Main execution function."""
+    # 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.py"
+    
+    print("Loading parsed units data for quantities...")
+    
+    # Setup import path and load data using shared processor
+    setup_import_path()
+    parsed_data = load_unit_data(parsed_file)
+    dimension_mapping = load_unit_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 quantities")
+    
+    # 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 quantities file
+    print("Generating quantities.py...")
+    content = generate_quantities(augmented_data, dimension_mapping)
+    
+    # Write output file
+    save_text_file(content, output_file)
+    print(f"Generated quantities file: {output_file}")
+    
+    # Print statistics using shared calculator
+    stats = calculate_statistics(augmented_data)
+    print("\nStatistics:")
+    print(f"  Total fields: {stats['total_fields']}")
+    print(f"  Fields with units: {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']}")
+    
+    # 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})")
+
+
+if __name__ == "__main__":
+    main()

qnty/codegen/generators/setters_gen.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""
+Script to generate comprehensive setters.py for all variable setters.
+
+This script generates static setter class definitions with unit properties
+for the fluent API with dimension-specific unit properties.
+"""
+
+from pathlib import Path
+
+try:
+    from .data_processor import (
+        augment_with_prefixed_units,
+        calculate_statistics,
+        convert_to_class_name,
+        get_dimension_constant_name,
+        get_unit_names_and_aliases,
+        load_unit_data,
+        save_text_file,
+        setup_import_path,
+    )
+except ImportError:
+    from .data_processor import (
+        augment_with_prefixed_units,
+        calculate_statistics,
+        convert_to_class_name,
+        get_dimension_constant_name,
+        get_unit_names_and_aliases,
+        load_unit_data,
+        save_text_file,
+        setup_import_path,
+    )
+
+
+def generate_setters(parsed_data: dict, dimension_mapping: dict) -> str:
+    """Generate the setters.py content with static setter class definitions."""
+    
+    sorted_fields = sorted(parsed_data.items())
+    fields_with_units = [(k, v) for k, v in sorted_fields if v.get('units')]
+    
+    lines = [
+        '"""',
+        'Setter Classes Module - Static Edition',
+        '======================================',
+        '',
+        'Static setter class definitions for maximum import performance.',
+        'Provides fluent API unit properties for all variable types.',
+        'Auto-generated from unit_data.json.',
+        '"""',
+        '',
+        'from ..quantities.quantity import Quantity, TypeSafeSetter',
+        'from . import units',
+        ''
+    ]
+    
+    # Generate all setter classes
+    lines.append('# ===== SETTER CLASSES =====')
+    lines.append('# Static setter class definitions with __slots__ optimization')
+    lines.append('')
+    
+    for field_name, field_data in fields_with_units:
+        class_name = convert_to_class_name(field_name)
+        setter_class_name = f"{class_name}Setter"
+        get_dimension_constant_name(field_name)
+        units_class_name = f"{class_name}Units"
+        
+        lines.append(f'class {setter_class_name}(TypeSafeSetter):')
+        lines.append(f'    """{class_name}-specific setter with optimized unit properties."""')
+        lines.append('    __slots__ = ()')
+        lines.append('    ')
+        
+        # Generate property for each unit, avoiding duplicates
+        generated_properties = set()
+        
+        for unit_data in field_data['units']:
+            primary_name, aliases = get_unit_names_and_aliases(unit_data)
+            # Use primary name for the main property
+            property_name = primary_name
+            
+            # Skip if this property name was already generated
+            if property_name in generated_properties:
+                continue
+            
+            generated_properties.add(property_name)
+            
+            lines.append('    @property')
+            lines.append(f'    def {property_name}(self):')
+            unit_display_name = unit_data.get('name', primary_name)
+            # Escape backslashes in the docstring to avoid escape sequence warnings
+            escaped_name = unit_display_name.replace('\\', '\\\\')
+            lines.append(f'        """Set value using {escaped_name} units."""')
+            lines.append(f'        unit_const = units.{units_class_name}.{property_name}')
+            lines.append('        self.variable.quantity = Quantity(self.value, unit_const)')
+            lines.append('        return self.variable')
+            lines.append('    ')
+            
+            # Add alias properties using shared processing
+            for alias in aliases:
+                # Only add if different from main property and not already generated
+                if (alias != property_name and
+                    alias.isidentifier() and
+                    alias not in generated_properties):
+                    generated_properties.add(alias)
+                    lines.append('    @property')
+                    lines.append(f'    def {alias}(self):')
+                    lines.append(f'        """Set value using {alias} units (alias for {primary_name})."""')
+                    lines.append(f'        return self.{property_name}')
+                    lines.append('    ')
+        
+        lines.append('')
+    
+    return '\n'.join(lines) + '\n'
+
+
+def main():
+    """Main execution function."""
+    # 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 / "setters.py"
+    
+    print("Loading parsed units data for setters...")
+    
+    # Setup import path and load data using shared processor
+    setup_import_path()
+    parsed_data = load_unit_data(parsed_file)
+    dimension_mapping = load_unit_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 setters")
+    
+    # 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 setters file
+    print("Generating setters.py...")
+    content = generate_setters(augmented_data, dimension_mapping)
+    
+    # Write output file
+    save_text_file(content, output_file)
+    print(f"Generated setters file: {output_file}")
+    
+    # Print statistics using shared calculator
+    stats = calculate_statistics(augmented_data)
+    print("\nStatistics:")
+    print(f"  Total fields: {stats['total_fields']}")
+    print(f"  Fields with units: {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']}")
+    
+    # Show top setter 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 setter types by unit property 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}Setter{'':<15} : {unit_count:>3} properties ({display_name})")
+
+
+if __name__ == "__main__":
+    main()