phaxor 1.0.0__tar.gz

phaxor-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Phaxor Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

phaxor-1.0.0/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: phaxor
+Version: 1.0.0
+Summary: Engineering Calculator Library — Ideal Gas, Ohm's Law, Mohr's Circle, Beam Analysis, and more with rich Jupyter output
+Author: Phaxor Team
+License: MIT License
+        
+        Copyright (c) 2026 Phaxor Team
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Keywords: engineering,calculator,physics,mechanical,electrical,structural,jupyter
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Framework :: Jupyter
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: jupyter
+Requires-Dist: ipython>=7.0; extra == "jupyter"
+Dynamic: license-file
+
+# 🔬 Phaxor — Engineering Calculator Library
+
+**Embeddable engineering calculations for JavaScript and Python.**
+
+## Install
+
+```bash
+pip install phaxor
+```
+
+## Quick Start
+
+```python
+import phaxor
+
+# Ideal Gas Law
+result = phaxor.compute('ideal-gas', {
+    'solveFor': 'pressure',
+    'volume': 0.02241,
+    'moles': 1,
+    'temperature': 273.15,
+    'gas': 'air'
+})
+print(f"Pressure = {result['P']:.0f} Pa")  # 101325 Pa
+
+# Ohm's Law
+result = phaxor.compute('ohms-law', {
+    'solveFor': 'I',
+    'voltage': 12,
+    'resistance': 100
+})
+print(f"Current = {result['I']} A")  # 0.12 A
+
+# Unit Conversion
+km = phaxor.convert('length', 1, 'mi', 'km')
+print(f"1 mile = {km:.6f} km")  # 1.609344 km
+
+# Mohr's Circle
+result = phaxor.compute('mohrs-circle', {
+    'sigmaX': 80,
+    'sigmaY': -40,
+    'tauXY': 30,
+    'theta': 25
+})
+print(f"σ₁ = {result['sigma1']:.1f} MPa")
+
+# List all calculators
+for calc in phaxor.list_calculators():
+    print(f"  {calc['id']:20s} {calc['name']}")
+```
+
+## Available Calculators
+
+| ID | Name | Category |
+|----|------|----------|
+| `ideal-gas` | Ideal Gas Law | Thermodynamics |
+| `ohms-law` | Ohm's Law | Electrical |
+| `mohrs-circle` | Mohr's Circle | Structural |
+| `gear-ratio` | Gear Ratio | Mechanical |
+| `heat-transfer` | Heat Transfer | Thermodynamics |
+| `column-buckling` | Column Buckling | Structural |
+| `stress-strain` | Stress & Strain | Structural |
+| `beam` | Beam Analysis | Structural |
+| `pipe-flow` | Pipe Flow | Fluid Mechanics |
+| `unit-converter` | Unit Converter | General |
+
+## Pipe Flow (Detailed Model)
+
+```python
+import phaxor
+
+# Pressure-driven solve using NPS + Schedule diameter lookup
+result = phaxor.compute('pipe-flow', {
+    'solveMode': 'known-pressures',
+    'nps': '4',
+    'schedule': '40',
+    'length': 120,
+    'roughness': 0.000045,
+    'minorLossK': 6.5,
+    'elevationChange': 5,
+    'inletPressure': 220,   # kPa gauge
+    'outletPressure': 0,    # kPa gauge
+    'density': 998,
+    'viscosity': 0.001002
+})
+
+print(f"Q = {result['flowRate']*3600:.2f} m3/h")
+print(f"ID source = {result['diameterSource']}")
+print(f"Delta P = {result['pressureDeltaKPa']:.2f} kPa")
+```
+
+The `pipe-flow` engine now supports:
+- `known-flow` and `known-pressures` boundary modes
+- Flow input by volumetric flow, mass flow, or velocity
+- Minor loss (`K`) and elevation/pump head terms
+- Pipe sizing by direct diameter or `nps + schedule`
+- Extended outputs (major/minor loss split, power estimates, turbulence initialization fields)
+
+## Jupyter Notebooks
+
+In Jupyter, calling `phaxor.compute()` automatically renders a styled HTML table:
+
+```python
+import phaxor
+
+# This renders a beautiful HTML table in Jupyter!
+phaxor.compute('ideal-gas', {
+    'solveFor': 'pressure',
+    'volume': 0.02241,
+    'moles': 1,
+    'temperature': 273.15,
+})
+```
+
+## API
+
+```python
+phaxor.compute(calculator_type, inputs)  # Run any calculator
+phaxor.convert(category, value, from_unit, to_unit)  # Unit conversion
+phaxor.list_calculators()  # List all available calculators
+```
+
+## License
+
+MIT

phaxor-1.0.0/README.md

@@ -0,0 +1,125 @@
+# 🔬 Phaxor — Engineering Calculator Library
+
+**Embeddable engineering calculations for JavaScript and Python.**
+
+## Install
+
+```bash
+pip install phaxor
+```
+
+## Quick Start
+
+```python
+import phaxor
+
+# Ideal Gas Law
+result = phaxor.compute('ideal-gas', {
+    'solveFor': 'pressure',
+    'volume': 0.02241,
+    'moles': 1,
+    'temperature': 273.15,
+    'gas': 'air'
+})
+print(f"Pressure = {result['P']:.0f} Pa")  # 101325 Pa
+
+# Ohm's Law
+result = phaxor.compute('ohms-law', {
+    'solveFor': 'I',
+    'voltage': 12,
+    'resistance': 100
+})
+print(f"Current = {result['I']} A")  # 0.12 A
+
+# Unit Conversion
+km = phaxor.convert('length', 1, 'mi', 'km')
+print(f"1 mile = {km:.6f} km")  # 1.609344 km
+
+# Mohr's Circle
+result = phaxor.compute('mohrs-circle', {
+    'sigmaX': 80,
+    'sigmaY': -40,
+    'tauXY': 30,
+    'theta': 25
+})
+print(f"σ₁ = {result['sigma1']:.1f} MPa")
+
+# List all calculators
+for calc in phaxor.list_calculators():
+    print(f"  {calc['id']:20s} {calc['name']}")
+```
+
+## Available Calculators
+
+| ID | Name | Category |
+|----|------|----------|
+| `ideal-gas` | Ideal Gas Law | Thermodynamics |
+| `ohms-law` | Ohm's Law | Electrical |
+| `mohrs-circle` | Mohr's Circle | Structural |
+| `gear-ratio` | Gear Ratio | Mechanical |
+| `heat-transfer` | Heat Transfer | Thermodynamics |
+| `column-buckling` | Column Buckling | Structural |
+| `stress-strain` | Stress & Strain | Structural |
+| `beam` | Beam Analysis | Structural |
+| `pipe-flow` | Pipe Flow | Fluid Mechanics |
+| `unit-converter` | Unit Converter | General |
+
+## Pipe Flow (Detailed Model)
+
+```python
+import phaxor
+
+# Pressure-driven solve using NPS + Schedule diameter lookup
+result = phaxor.compute('pipe-flow', {
+    'solveMode': 'known-pressures',
+    'nps': '4',
+    'schedule': '40',
+    'length': 120,
+    'roughness': 0.000045,
+    'minorLossK': 6.5,
+    'elevationChange': 5,
+    'inletPressure': 220,   # kPa gauge
+    'outletPressure': 0,    # kPa gauge
+    'density': 998,
+    'viscosity': 0.001002
+})
+
+print(f"Q = {result['flowRate']*3600:.2f} m3/h")
+print(f"ID source = {result['diameterSource']}")
+print(f"Delta P = {result['pressureDeltaKPa']:.2f} kPa")
+```
+
+The `pipe-flow` engine now supports:
+- `known-flow` and `known-pressures` boundary modes
+- Flow input by volumetric flow, mass flow, or velocity
+- Minor loss (`K`) and elevation/pump head terms
+- Pipe sizing by direct diameter or `nps + schedule`
+- Extended outputs (major/minor loss split, power estimates, turbulence initialization fields)
+
+## Jupyter Notebooks
+
+In Jupyter, calling `phaxor.compute()` automatically renders a styled HTML table:
+
+```python
+import phaxor
+
+# This renders a beautiful HTML table in Jupyter!
+phaxor.compute('ideal-gas', {
+    'solveFor': 'pressure',
+    'volume': 0.02241,
+    'moles': 1,
+    'temperature': 273.15,
+})
+```
+
+## API
+
+```python
+phaxor.compute(calculator_type, inputs)  # Run any calculator
+phaxor.convert(category, value, from_unit, to_unit)  # Unit conversion
+phaxor.list_calculators()  # List all available calculators
+```
+
+## License
+
+MIT

phaxor-1.0.0/phaxor/__init__.py

@@ -0,0 +1,188 @@
+"""Phaxor Engineering Calculator Library for Python."""
+
+__version__ = "1.0.0"
+
+from .engines.arrhenius import solve_arrhenius
+from .engines.cstr import solve_cstr
+from .engines.chem_equilibrium import solve_chem_equilibrium
+from .engines.distillation import solve_distillation
+from .engines.gibbs import solve_gibbs
+from .engines.pfr import solve_pfr
+from .engines.packed_bed import solve_packed_bed
+from .engines.stoichiometry import solve_stoichiometry
+from .engines.vle import solve_vle
+from .engines.battery_ups import solve_battery_ups
+from .engines.cable_sizing import solve_cable_sizing
+from .engines.circuit_breaker import solve_circuit_breaker
+from .engines.dc_motor import solve_dc_motor
+from .engines.earthing import solve_earthing
+from .engines.electrical_efficiency import solve_electrical_efficiency
+from .engines.energy_consumption import solve_energy_consumption
+from .engines.impedance import solve_impedance
+from .engines.induction_motor import solve_induction_motor
+from .engines.ohms_law import solve_ohms_law
+from .engines.power import solve_ac_power
+from .engines.pf_correction import solve_pf_correction
+from .engines.rectifier import solve_rectifier
+from .engines.resonance import solve_resonance
+from .engines.short_circuit import solve_short_circuit
+from .engines.solar_sizing import solve_solar_sizing
+from .engines.transformer import solve_transformer
+from .engines.geometry import solve_geometry
+from .engines.matrix import solve_matrix
+from .engines.unit_converter import convert_unit, get_categories, get_units
+from .engines.open_channel import solve_open_channel
+from .engines.pavement_thickness import solve_pavement_thickness
+from .engines.sight_distance import solve_sight_distance
+from .engines.weir_orifice import solve_weir_orifice
+from .engines.apf import solve_apf
+from .engines.corrosion import solve_corrosion
+from .engines.fatigue_life import solve_fatigue_life
+from .engines.hardness_conversion import solve_hardness_conversion
+from .engines.rule_of_mixtures import solve_rule_of_mixtures
+from .engines.beam import solve_beam
+from .engines.bearing_life import solve_bearing_life
+from .engines.belt_drive import solve_belt_drive
+from .engines.bolt_analysis import solve_bolt_analysis
+from .engines.cop import solve_cop
+from .engines.flywheel import solve_flywheel
+from .engines.gear_ratio import solve_gear_ratio
+from .engines.heat_exchanger import solve_heat_exchanger
+from .engines.heat_transfer import solve_heat_transfer
+from .engines.ideal_gas import solve_ideal_gas, GASES, R_UNIVERSAL
+from .engines.pipe_flow import solve_pipe_flow
+from .engines.pressure_force import solve_pressure_force
+from .engines.pump_power import solve_pump_power
+from .engines.rankine_cycle import solve_rankine_cycle
+from .engines.shaft_design import solve_shaft_design
+from .engines.spring_design import solve_spring_design
+from .engines.torque_power import solve_torque_power
+from .engines.vibration import solve_vibration
+from .engines.weld_strength import solve_weld_strength
+from .engines.beam_deflection import solve_beam_deflection
+from .engines.bearing_capacity import solve_bearing_capacity
+from .engines.column_buckling import solve_column_buckling, calc_column_section
+from .engines.concrete_volume import solve_concrete_volume
+from .engines.development_length import solve_development_length
+from .engines.earth_pressure import solve_earth_pressure
+from .engines.failure_theory import solve_failure_theory
+from .engines.isolated_footing import solve_isolated_footing
+from .engines.mohrs_circle import solve_mohrs_circle
+from .engines.rcc_beam import solve_rcc_beam
+from .engines.rcc_column import solve_rcc_column
+from .engines.rcc_slab import solve_rcc_slab
+from .engines.reinforcement_qty import solve_reinforcement_qty
+from .engines.settlement import solve_settlement
+from .engines.soil_properties import solve_soil_properties
+from .engines.steel_weight import solve_steel_weight
+from .engines.stress_strain import solve_stress_strain, calc_area, MATERIALS as STRESS_MATERIALS
+from .display import display_result
+
+CALCULATORS = {
+    'arrhenius': {'name': 'Arrhenius', 'category': 'Chemical', 'solver': solve_arrhenius},
+    'cstr': {'name': 'CSTR Design', 'category': 'Chemical', 'solver': solve_cstr},
+    'chem-equilibrium': {'name': 'Chem Equilibrium', 'category': 'Chemical', 'solver': solve_chem_equilibrium},
+    'distillation': {'name': 'Distillation', 'category': 'Chemical', 'solver': solve_distillation},
+    'gibbs': {'name': 'Gibbs', 'category': 'Chemical', 'solver': solve_gibbs},
+    'pfr': {'name': 'PFR Design', 'category': 'Chemical', 'solver': solve_pfr},
+    'packed-bed': {'name': 'Packed Bed', 'category': 'Chemical', 'solver': solve_packed_bed},
+    'stoichiometry': {'name': 'Stoichiometry', 'category': 'Chemical', 'solver': solve_stoichiometry},
+    'vle': {'name': 'VLE / Phase Equilibrium', 'category': 'Chemical', 'solver': solve_vle},
+    'battery-ups': {'name': 'Battery Ups', 'category': 'Electrical', 'solver': solve_battery_ups},
+    'cable-sizing': {'name': 'Cable Sizing', 'category': 'Electrical', 'solver': solve_cable_sizing},
+    'circuit-breaker': {'name': 'Circuit Breaker', 'category': 'Electrical', 'solver': solve_circuit_breaker},
+    'dc-motor': {'name': 'DC Motor', 'category': 'Electrical', 'solver': solve_dc_motor},
+    'earthing': {'name': 'Earthing', 'category': 'Electrical', 'solver': solve_earthing},
+    'electrical-efficiency': {'name': 'Electrical Efficiency', 'category': 'Electrical', 'solver': solve_electrical_efficiency},
+    'energy-consumption': {'name': 'Energy Consumption', 'category': 'Electrical', 'solver': solve_energy_consumption},
+    'impedance': {'name': 'Impedance', 'category': 'Electrical', 'solver': solve_impedance},
+    'induction-motor': {'name': 'Induction Motor', 'category': 'Electrical', 'solver': solve_induction_motor},
+    'ohms-law': {'name': 'Ohm\'s Law', 'category': 'Electrical', 'solver': solve_ohms_law},
+    'power': {'name': 'Power', 'category': 'Electrical', 'solver': solve_ac_power},
+    'pf-correction': {'name': 'Power Factor Correction', 'category': 'Electrical', 'solver': solve_pf_correction},
+    'rectifier': {'name': 'Rectifier', 'category': 'Electrical', 'solver': solve_rectifier},
+    'resonance': {'name': 'Resonance', 'category': 'Electrical', 'solver': solve_resonance},
+    'short-circuit': {'name': 'Short Circuit', 'category': 'Electrical', 'solver': solve_short_circuit},
+    'solar-sizing': {'name': 'Solar Sizing', 'category': 'Electrical', 'solver': solve_solar_sizing},
+    'transformer': {'name': 'Transformer', 'category': 'Electrical', 'solver': solve_transformer},
+    'geometry': {'name': 'Geometry', 'category': 'General', 'solver': solve_geometry},
+    'matrix': {'name': 'Matrix', 'category': 'General', 'solver': solve_matrix},
+    'unit-converter': {'name': 'Unit Converter', 'category': 'General', 'solver': convert_unit},
+    'open-channel': {'name': 'Open Channel Flow', 'category': 'Hydraulics', 'solver': solve_open_channel},
+    'pavement-thickness': {'name': 'Pavement Thickness', 'category': 'Hydraulics', 'solver': solve_pavement_thickness},
+    'sight-distance': {'name': 'Sight Distance', 'category': 'Hydraulics', 'solver': solve_sight_distance},
+    'weir-orifice': {'name': 'Weir & Orifice', 'category': 'Hydraulics', 'solver': solve_weir_orifice},
+    'apf': {'name': 'Atomic Packing Factor', 'category': 'Materials', 'solver': solve_apf},
+    'corrosion': {'name': 'Corrosion', 'category': 'Materials', 'solver': solve_corrosion},
+    'fatigue-life': {'name': 'Fatigue Life', 'category': 'Materials', 'solver': solve_fatigue_life},
+    'hardness-conversion': {'name': 'Hardness Conversion', 'category': 'Materials', 'solver': solve_hardness_conversion},
+    'rule-of-mixtures': {'name': 'Rule of Mixtures', 'category': 'Materials', 'solver': solve_rule_of_mixtures},
+    'beam': {'name': 'Beam', 'category': 'Mechanical', 'solver': solve_beam},
+    'bearing-life': {'name': 'Bearing Life', 'category': 'Mechanical', 'solver': solve_bearing_life},
+    'belt-drive': {'name': 'Belt Drive', 'category': 'Mechanical', 'solver': solve_belt_drive},
+    'bolt-analysis': {'name': 'Bolt Analysis', 'category': 'Mechanical', 'solver': solve_bolt_analysis},
+    'cop': {'name': 'Coefficient of Performance', 'category': 'Mechanical', 'solver': solve_cop},
+    'flywheel': {'name': 'Flywheel', 'category': 'Mechanical', 'solver': solve_flywheel},
+    'gear-ratio': {'name': 'Gear Ratio', 'category': 'Mechanical', 'solver': solve_gear_ratio},
+    'heat-exchanger': {'name': 'Heat Exchanger', 'category': 'Mechanical', 'solver': solve_heat_exchanger},
+    'heat-transfer': {'name': 'Heat Transfer', 'category': 'Mechanical', 'solver': solve_heat_transfer},
+    'ideal-gas': {'name': 'Ideal Gas Law', 'category': 'Mechanical', 'solver': solve_ideal_gas},
+    'pipe-flow': {'name': 'Pipe Flow', 'category': 'Mechanical', 'solver': solve_pipe_flow},
+    'pressure-force': {'name': 'Pressure Force', 'category': 'Mechanical', 'solver': solve_pressure_force},
+    'pump-power': {'name': 'Pump Power', 'category': 'Mechanical', 'solver': solve_pump_power},
+    'rankine-cycle': {'name': 'Rankine Cycle', 'category': 'Mechanical', 'solver': solve_rankine_cycle},
+    'shaft-design': {'name': 'Shaft Design', 'category': 'Mechanical', 'solver': solve_shaft_design},
+    'spring-design': {'name': 'Spring Design', 'category': 'Mechanical', 'solver': solve_spring_design},
+    'torque-power': {'name': 'Torque Power', 'category': 'Mechanical', 'solver': solve_torque_power},
+    'vibration': {'name': 'Vibration', 'category': 'Mechanical', 'solver': solve_vibration},
+    'weld-strength': {'name': 'Weld Strength', 'category': 'Mechanical', 'solver': solve_weld_strength},
+    'beam-deflection': {'name': 'Beam Deflection', 'category': 'Structural', 'solver': solve_beam_deflection},
+    'bearing-capacity': {'name': 'Bearing Capacity', 'category': 'Structural', 'solver': solve_bearing_capacity},
+    'column-buckling': {'name': 'Column Buckling', 'category': 'Structural', 'solver': solve_column_buckling},
+    'concrete-volume': {'name': 'Concrete Volume', 'category': 'Structural', 'solver': solve_concrete_volume},
+    'development-length': {'name': 'Development Length', 'category': 'Structural', 'solver': solve_development_length},
+    'earth-pressure': {'name': 'Earth Pressure', 'category': 'Structural', 'solver': solve_earth_pressure},
+    'failure-theory': {'name': 'Failure Theory', 'category': 'Structural', 'solver': solve_failure_theory},
+    'isolated-footing': {'name': 'Isolated Footing', 'category': 'Structural', 'solver': solve_isolated_footing},
+    'mohrs-circle': {'name': 'Mohr\'s Circle', 'category': 'Structural', 'solver': solve_mohrs_circle},
+    'rcc-beam': {'name': 'RCC Beam Design', 'category': 'Structural', 'solver': solve_rcc_beam},
+    'rcc-column': {'name': 'RCC Column Design', 'category': 'Structural', 'solver': solve_rcc_column},
+    'rcc-slab': {'name': 'RCC Slab Design', 'category': 'Structural', 'solver': solve_rcc_slab},
+    'reinforcement-qty': {'name': 'Reinforcement Qty', 'category': 'Structural', 'solver': solve_reinforcement_qty},
+    'settlement': {'name': 'Settlement', 'category': 'Structural', 'solver': solve_settlement},
+    'soil-properties': {'name': 'Soil Properties', 'category': 'Structural', 'solver': solve_soil_properties},
+    'steel-weight': {'name': 'Steel Weight', 'category': 'Structural', 'solver': solve_steel_weight},
+    'stress-strain': {'name': 'Stress Strain', 'category': 'Structural', 'solver': solve_stress_strain},
+}
+
+def compute(calculator_type: str, inputs: dict) -> dict:
+    """Run a calculator engine and return results."""
+    calc = CALCULATORS.get(calculator_type)
+    if not calc:
+        available = ', '.join(CALCULATORS.keys())
+        raise ValueError(f"Unknown calculator: '{calculator_type}'. Available: {available}")
+    result = calc['solver'](inputs)
+    try:
+        display_result(calculator_type, calc['name'], inputs, result)
+    except Exception:
+        pass
+    return result
+
+def convert(category: str, value: float, from_unit: str, to_unit: str) -> float:
+    """Convert a value between units."""
+    result = convert_unit({
+        'category': category,
+        'value': value,
+        'fromUnit': from_unit,
+        'toUnit': to_unit,
+    })
+    if result is None:
+        raise ValueError(f"Cannot convert {from_unit} -> {to_unit} in category '{category}'")
+    return result['value']
+
+def list_calculators() -> list:
+    """List all available calculators."""
+    return [
+        {'id': k, 'name': v['name'], 'category': v['category']}
+        for k, v in CALCULATORS.items()
+    ]

phaxor-1.0.0/phaxor/display.py

@@ -0,0 +1,60 @@
+"""
+Phaxor — Rich Jupyter Notebook Display
+Renders engineering results as styled HTML tables in Jupyter notebooks.
+"""
+
+
+def display_result(calculator_type: str, name: str, inputs: dict, result: dict | None):
+    """
+    Display a styled HTML table of results in Jupyter notebooks.
+    Falls back silently if not in a Jupyter environment.
+    """
+    try:
+        from IPython.display import display, HTML
+    except ImportError:
+        return  # Not in Jupyter
+
+    if result is None:
+        display(HTML(f"""
+            <div style="padding:16px;background:#1a1b26;border:1px solid #ef4444;border-radius:12px;
+                        font-family:system-ui;color:#f87171;">
+                ⚠️ <strong>{name}</strong> — Invalid inputs. Check your parameters.
+            </div>
+        """))
+        return
+
+    # Filter out complex nested data for clean display
+    display_items = {}
+    for k, v in result.items():
+        if isinstance(v, (int, float)):
+            display_items[k] = f"{v:,.6g}"
+        elif isinstance(v, str):
+            display_items[k] = v
+        elif isinstance(v, bool):
+            display_items[k] = '✅ Yes' if v else '❌ No'
+
+    rows_html = ''.join(
+        f"""<tr>
+            <td style="padding:8px 12px;border-bottom:1px solid #2f334d;font-weight:600;color:#7aa2f7;
+                        font-family:monospace;font-size:13px;">{k}</td>
+            <td style="padding:8px 12px;border-bottom:1px solid #2f334d;font-size:13px;">{v}</td>
+        </tr>"""
+        for k, v in display_items.items()
+    )
+
+    html = f"""
+    <div style="font-family:'Inter',system-ui,sans-serif;max-width:600px;margin:12px 0;">
+        <div style="background:#1a1b26;border:1px solid #2f334d;border-radius:12px;overflow:hidden;">
+            <div style="padding:14px 16px;background:linear-gradient(135deg,#22d3ee22,#a855f722);
+                        display:flex;align-items:center;gap:8px;">
+                <div style="width:8px;height:8px;border-radius:50%;background:#22d3ee;"></div>
+                <strong style="color:#c0caf5;font-size:15px;">{name}</strong>
+                <span style="margin-left:auto;font-size:10px;color:#565f89;">Phaxor v1.0</span>
+            </div>
+            <table style="width:100%;border-collapse:collapse;color:#c0caf5;">
+                {rows_html}
+            </table>
+        </div>
+    </div>
+    """
+    display(HTML(html))

phaxor-1.0.0/phaxor/engines/__init__.py

@@ -0,0 +1 @@
+"""Engine sub-package."""

phaxor-1.0.0/phaxor/engines/apf.py

@@ -0,0 +1,56 @@
+"""Phaxor — Atomic Packing Factor Engine (Python port)"""
+import math
+
+def solve_apf(inputs: dict) -> dict | None:
+    """APF Calculator."""
+    structure = inputs.get('structure', 'BCC')
+    radius = float(inputs.get('radius', 0))
+    molar_mass = float(inputs.get('molarMass', 0))
+
+    if radius <= 0 or molar_mass <= 0:
+        return None
+
+    na = 6.022e23
+    n = 0
+    apf = 0.0
+    a = 0.0
+    v_nm3 = 0.0
+
+    if structure == 'SC':
+        n = 1
+        apf = 0.5236
+        a = 2 * radius
+        v_nm3 = a ** 3
+    elif structure == 'BCC':
+        n = 2
+        apf = 0.6802
+        a = 4 * radius / math.sqrt(3)
+        v_nm3 = a ** 3
+    elif structure == 'FCC':
+        n = 4
+        apf = 0.7405
+        a = 2 * math.sqrt(2) * radius
+        v_nm3 = a ** 3
+    elif structure == 'HCP':
+        n = 6
+        apf = 0.7405
+        a = 2 * radius
+        v_nm3 = 3 * math.sqrt(2) * (a ** 3)
+    elif structure == 'Diamond':
+        n = 8
+        apf = 0.3401
+        a = 8 * radius / math.sqrt(3)
+        v_nm3 = a ** 3
+    
+    v_cm3 = v_nm3 * 1e-21
+    rho = (n * molar_mass) / (na * v_cm3) if v_cm3 > 0 else 0
+    void_frac = 1.0 - apf
+
+    return {
+        'apf': apf,
+        'a': float(f"{a:.4f}"),
+        'rho': float(f"{rho:.2f}"),
+        'V_nm3': float(f"{v_nm3:.4f}"),
+        'n': n,
+        'voidFrac': float(f"{void_frac:.3f}")
+    }

phaxor-1.0.0/phaxor/engines/arrhenius.py

@@ -0,0 +1,46 @@
+"""Phaxor — Arrhenius Engine (Python port)"""
+import math
+
+R_GAS = 8.314
+
+def solve_arrhenius(inputs: dict) -> dict | None:
+    """Arrhenius Equation Calculator."""
+    a = float(inputs.get('A', 0))
+    ea = float(inputs.get('Ea', 0))
+    t1 = float(inputs.get('T1', 0))
+    t2 = float(inputs.get('T2', 0))
+
+    if a <= 0 or ea <= 0 or t1 <= 0:
+        return None
+
+    k1 = a * math.exp(-ea / (R_GAS * t1))
+    k2 = a * math.exp(-ea / (R_GAS * t2)) if t2 > 0 else 0
+    ratio = k2 / k1 if (k2 > 0 and k1 > 0) else 0
+
+    slope = -ea / R_GAS
+    half_life = math.log(2) / k1 if k1 > 0 else 0
+
+    plot_data = []
+    t_min = max(200, t1 - 200)
+    t_max = max(t2 + 200, t1 + 200) if t2 > 0 else t1 + 400
+    step = (t_max - t_min) / 50
+
+    curr_t = t_min
+    while curr_t <= t_max:
+        if curr_t > 0:
+            k_val = a * math.exp(-ea / (R_GAS * curr_t))
+            plot_data.append({
+                'invT': float(f"{1000/curr_t:.4f}"),
+                'lnk': float(f"{math.log(k_val):.3f}"),
+                'T': int(curr_t)
+            })
+        curr_t += step
+
+    return {
+        'k1': k1,
+        'k2': k2,
+        'ratio': float(f"{ratio:.2f}"),
+        'slope': float(f"{slope:.2f}"),
+        'halfLife1st': half_life,
+        'plotData': plot_data
+    }