api581-engine 0.1.4__py3-none-any.whl

api581/api/financial.py

@@ -0,0 +1,115 @@
+"""Public financial calculations. Inputs and outputs use named SI units.
+Generated by scripts/build_python_api.py; inspect the request model for fields.
+"""
+from ..core import Context
+from ..result import CalculationResult, calculate
+
+from ..cost_tables import ComponentOutage as Cost_tablesComponentOutageInput
+from ..consequences import HoleFinancial as HoleFinancialInput
+from ..cost_tables import RepairCost as RepairCostInput
+
+from ..consequences import SurroundingCost as SurroundingDamageInput
+from ..outputs import FinancialSurroundingDamageOutput as SurroundingDamageOutput
+
+def surrounding_damage(inputs: SurroundingDamageInput, *, context: Context | None = None) -> CalculationResult[SurroundingDamageOutput]:
+    'Surrounding equipment damage cost'
+    return calculate('financial/surrounding-damage', inputs, output_type=SurroundingDamageOutput, context=context)
+
+
+from ..consequences import ProductionCost as ProductionLossInput
+from ..outputs import FinancialProductionLossOutput as ProductionLossOutput
+
+def production_loss(inputs: ProductionLossInput, *, context: Context | None = None) -> CalculationResult[ProductionLossOutput]:
+    'Business interruption cost'
+    return calculate('financial/production-loss', inputs, output_type=ProductionLossOutput, context=context)
+
+
+from ..consequences import InjuryCost as InjuryInput
+from ..outputs import FinancialInjuryOutput as InjuryOutput
+
+def injury(inputs: InjuryInput, *, context: Context | None = None) -> CalculationResult[InjuryOutput]:
+    'Potential injury cost'
+    return calculate('financial/injury', inputs, output_type=InjuryOutput, context=context)
+
+
+from ..consequences import Spill as SpillCleanupInput
+from ..outputs import FinancialSpillCleanupOutput as SpillCleanupOutput
+
+def spill_cleanup(inputs: SpillCleanupInput, *, context: Context | None = None) -> CalculationResult[SpillCleanupOutput]:
+    'Liquid spill remediation volume and cost'
+    return calculate('financial/spill-cleanup', inputs, output_type=SpillCleanupOutput, context=context)
+
+
+from ..consequences import FinancialByHole as HoleTotalInput
+from ..outputs import FinancialHoleTotalOutput as HoleTotalOutput
+
+def hole_total(inputs: HoleTotalInput, *, context: Context | None = None) -> CalculationResult[HoleTotalOutput]:
+    'Four-hole financial consequence and annual risk roll-up'
+    return calculate('financial/hole-total', inputs, output_type=HoleTotalOutput, context=context)
+
+
+from ..pof import Component as RepairTableInput
+from ..outputs import FinancialRepairTableOutput as RepairTableOutput
+
+def repair_table(inputs: RepairTableInput, *, context: Context | None = None) -> CalculationResult[RepairTableOutput]:
+    '2001 USD component repair cost table'
+    return calculate('financial/repair-table', inputs, output_type=RepairTableOutput, context=context)
+
+
+from ..cost_tables import Material as MaterialFactorInput
+from ..outputs import FinancialMaterialFactorOutput as MaterialFactorOutput
+
+def material_factor(inputs: MaterialFactorInput, *, context: Context | None = None) -> CalculationResult[MaterialFactorOutput]:
+    'Material repair cost multiplier'
+    return calculate('financial/material-factor', inputs, output_type=MaterialFactorOutput, context=context)
+
+
+from ..pof import Component as OutageTableInput
+from ..outputs import FinancialOutageTableOutput as OutageTableOutput
+
+def outage_table(inputs: OutageTableInput, *, context: Context | None = None) -> CalculationResult[OutageTableOutput]:
+    'Estimated equipment outage table'
+    return calculate('financial/outage-table', inputs, output_type=OutageTableOutput, context=context)
+
+
+from ..cost_tables import RepairCost as ComponentRepairInput
+from ..outputs import FinancialComponentRepairOutput as ComponentRepairOutput
+
+def component_repair(inputs: ComponentRepairInput, *, context: Context | None = None) -> CalculationResult[ComponentRepairOutput]:
+    'GFF-weighted material-adjusted component repair cost'
+    return calculate('financial/component-repair', inputs, output_type=ComponentRepairOutput, context=context)
+
+
+from ..cost_tables import ComponentOutage as ComponentOutageInput
+from ..outputs import FinancialComponentOutageOutput as ComponentOutageOutput
+
+def component_outage(inputs: ComponentOutageInput, *, context: Context | None = None) -> CalculationResult[ComponentOutageOutput]:
+    'GFF-weighted component outage duration'
+    return calculate('financial/component-outage', inputs, output_type=ComponentOutageOutput, context=context)
+
+
+from ..cost_tables import SurroundingOutage as SurroundingOutageInput
+from ..outputs import FinancialSurroundingOutageOutput as SurroundingOutageOutput
+
+def surrounding_outage(inputs: SurroundingOutageInput, *, context: Context | None = None) -> CalculationResult[SurroundingOutageOutput]:
+    'Surrounding equipment repair outage correlation'
+    return calculate('financial/surrounding-outage', inputs, output_type=SurroundingOutageOutput, context=context)
+
+
+from ..cost_tables import CleanupEligibility as CleanupEligibilityInput
+from ..outputs import FinancialCleanupEligibilityOutput as CleanupEligibilityOutput
+
+def cleanup_eligibility(inputs: CleanupEligibilityInput, *, context: Context | None = None) -> CalculationResult[CleanupEligibilityOutput]:
+    'Level 1 environmental cleanup screening'
+    return calculate('financial/cleanup-eligibility', inputs, output_type=CleanupEligibilityOutput, context=context)
+
+
+from ..cost_tables import FinancialConsequence as Level1ConsequenceInput
+from ..outputs import FinancialLevel1ConsequenceOutput as Level1ConsequenceOutput
+
+def level1_consequence(inputs: Level1ConsequenceInput, *, context: Context | None = None) -> CalculationResult[Level1ConsequenceOutput]:
+    'Compose five Level 1 financial consequence categories'
+    return calculate('financial/level1-consequence', inputs, output_type=Level1ConsequenceOutput, context=context)
+
+
+__all__ = ['Cost_tablesComponentOutageInput', 'HoleFinancialInput', 'RepairCostInput', 'surrounding_damage', 'SurroundingDamageInput', 'SurroundingDamageOutput', 'production_loss', 'ProductionLossInput', 'ProductionLossOutput', 'injury', 'InjuryInput', 'InjuryOutput', 'spill_cleanup', 'SpillCleanupInput', 'SpillCleanupOutput', 'hole_total', 'HoleTotalInput', 'HoleTotalOutput', 'repair_table', 'RepairTableInput', 'RepairTableOutput', 'material_factor', 'MaterialFactorInput', 'MaterialFactorOutput', 'outage_table', 'OutageTableInput', 'OutageTableOutput', 'component_repair', 'ComponentRepairInput', 'ComponentRepairOutput', 'component_outage', 'ComponentOutageInput', 'ComponentOutageOutput', 'surrounding_outage', 'SurroundingOutageInput', 'SurroundingOutageOutput', 'cleanup_eligibility', 'CleanupEligibilityInput', 'CleanupEligibilityOutput', 'level1_consequence', 'Level1ConsequenceInput', 'Level1ConsequenceOutput']

api581/api/frequency.py

@@ -0,0 +1,40 @@
+"""Public frequency calculations. Inputs and outputs use named SI units.
+Generated by scripts/build_python_api.py; inspect the request model for fields.
+"""
+from ..core import Context
+from ..result import CalculationResult, calculate
+
+
+from ..pof import Component as GenericInput
+from ..outputs import FrequencyGenericOutput as GenericOutput
+
+def generic(inputs: GenericInput, *, context: Context | None = None) -> CalculationResult[GenericOutput]:
+    'Component generic failure frequencies'
+    return calculate('frequency/generic', inputs, output_type=GenericOutput, context=context)
+
+
+from ..pof import Management as ManagementFactorInput
+from ..outputs import FrequencyManagementFactorOutput as ManagementFactorOutput
+
+def management_factor(inputs: ManagementFactorInput, *, context: Context | None = None) -> CalculationResult[ManagementFactorOutput]:
+    'Management systems factor'
+    return calculate('frequency/management-factor', inputs, output_type=ManagementFactorOutput, context=context)
+
+
+from ..pof import Frequency as AdjustedInput
+from ..outputs import FrequencyAdjustedOutput as AdjustedOutput
+
+def adjusted(inputs: AdjustedInput, *, context: Context | None = None) -> CalculationResult[AdjustedOutput]:
+    'Damage-adjusted annual failure frequency'
+    return calculate('frequency/adjusted', inputs, output_type=AdjustedOutput, context=context)
+
+
+from ..pof import PofMethodSelection as PofMethodSelectionInput
+from ..outputs import FrequencyPofMethodSelectionOutput as PofMethodSelectionOutput
+
+def pof_method_selection(inputs: PofMethodSelectionInput, *, context: Context | None = None) -> CalculationResult[PofMethodSelectionOutput]:
+    'Probability-of-failure methodology selection'
+    return calculate('frequency/pof-method-selection', inputs, output_type=PofMethodSelectionOutput, context=context)
+
+
+__all__ = ['generic', 'GenericInput', 'GenericOutput', 'management_factor', 'ManagementFactorInput', 'ManagementFactorOutput', 'adjusted', 'AdjustedInput', 'AdjustedOutput', 'pof_method_selection', 'PofMethodSelectionInput', 'PofMethodSelectionOutput']

api581/api/inspection.py

@@ -0,0 +1,96 @@
+"""Public inspection calculations. Inputs and outputs use named SI units.
+Generated by scripts/build_python_api.py; inspect the request model for fields.
+"""
+from ..core import Context
+from ..result import CalculationResult, calculate
+
+
+from ..pof import InspectionEquivalent as EquivalentInput
+from ..outputs import InspectionEquivalentOutput as EquivalentOutput
+
+def equivalent(inputs: EquivalentInput, *, context: Context | None = None) -> CalculationResult[EquivalentOutput]:
+    'Equivalent inspection counts'
+    return calculate('inspection/equivalent', inputs, output_type=EquivalentOutput, context=context)
+
+
+from ..pof import InspectionEffectivenessSummary as EffectivenessSummaryInput
+from ..outputs import InspectionEffectivenessSummaryOutput as EffectivenessSummaryOutput
+
+def effectiveness_summary(inputs: EffectivenessSummaryInput, *, context: Context | None = None) -> CalculationResult[EffectivenessSummaryOutput]:
+    'Combine inspection effectiveness history into highest category and equivalent counts'
+    return calculate('inspection/effectiveness-summary', inputs, output_type=EffectivenessSummaryOutput, context=context)
+
+
+from ..inspection_effectiveness import EffectivenessCategory as EffectivenessCategoryInput
+from ..outputs import InspectionEffectivenessCategoryOutput as EffectivenessCategoryOutput
+
+def effectiveness_category(inputs: EffectivenessCategoryInput, *, context: Context | None = None) -> CalculationResult[EffectivenessCategoryOutput]:
+    'API 581 Annex 2.C common inspection effectiveness category metadata'
+    return calculate('inspection/effectiveness-category', inputs, output_type=EffectivenessCategoryOutput, context=context)
+
+
+from ..inspection_effectiveness import ThinningInspectionEffectiveness as ThinningEffectivenessInput
+from ..outputs import InspectionThinningEffectivenessOutput as ThinningEffectivenessOutput
+
+def thinning_effectiveness(inputs: ThinningEffectivenessInput, *, context: Context | None = None) -> CalculationResult[ThinningEffectivenessOutput]:
+    'API 581 Annex 2.C.8 thinning inspection effectiveness category'
+    return calculate('inspection/thinning-effectiveness', inputs, output_type=ThinningEffectivenessOutput, context=context)
+
+
+from ..inspection_effectiveness import SccInspectionEffectiveness as SccEffectivenessInput
+from ..outputs import InspectionSccEffectivenessOutput as SccEffectivenessOutput
+
+def scc_effectiveness(inputs: SccEffectivenessInput, *, context: Context | None = None) -> CalculationResult[SccEffectivenessOutput]:
+    'API 581 Annex 2.C.9 stress-corrosion-cracking inspection effectiveness category'
+    return calculate('inspection/scc-effectiveness', inputs, output_type=SccEffectivenessOutput, context=context)
+
+
+from ..inspection_effectiveness import ExternalInspectionEffectiveness as ExternalEffectivenessInput
+from ..outputs import InspectionExternalEffectivenessOutput as ExternalEffectivenessOutput
+
+def external_effectiveness(inputs: ExternalEffectivenessInput, *, context: Context | None = None) -> CalculationResult[ExternalEffectivenessOutput]:
+    'API 581 Annex 2.C.10 external-damage inspection effectiveness category'
+    return calculate('inspection/external-effectiveness', inputs, output_type=ExternalEffectivenessOutput, context=context)
+
+
+from ..inspection_effectiveness import BuriedInspectionEffectiveness as BuriedEffectivenessInput
+from ..outputs import InspectionBuriedEffectivenessOutput as BuriedEffectivenessOutput
+
+def buried_effectiveness(inputs: BuriedEffectivenessInput, *, context: Context | None = None) -> CalculationResult[BuriedEffectivenessOutput]:
+    'API 581 Annex 2.C.7 buried-component inspection effectiveness category'
+    return calculate('inspection/buried-effectiveness', inputs, output_type=BuriedEffectivenessOutput, context=context)
+
+
+from ..inspection_effectiveness import PrdInspectionEffectiveness as PrdEffectivenessInput
+from ..outputs import InspectionPrdEffectivenessOutput as PrdEffectivenessOutput
+
+def prd_effectiveness(inputs: PrdEffectivenessInput, *, context: Context | None = None) -> CalculationResult[PrdEffectivenessOutput]:
+    'API 581 Annex 2.C.3 pressure-relief-device inspection effectiveness category'
+    return calculate('inspection/prd-effectiveness', inputs, output_type=PrdEffectivenessOutput, context=context)
+
+
+from ..inspection_effectiveness import LiningInspectionEffectiveness as LiningEffectivenessInput
+from ..outputs import InspectionLiningEffectivenessOutput as LiningEffectivenessOutput
+
+def lining_effectiveness(inputs: LiningEffectivenessInput, *, context: Context | None = None) -> CalculationResult[LiningEffectivenessOutput]:
+    'API 581 Annex 2.C.6 non-metallic lining inspection effectiveness category'
+    return calculate('inspection/lining-effectiveness', inputs, output_type=LiningEffectivenessOutput, context=context)
+
+
+from ..inspection_effectiveness import TubeBundleInspectionUncertainty as TubeBundleUncertaintyInput
+from ..outputs import InspectionTubeBundleUncertaintyOutput as TubeBundleUncertaintyOutput
+
+def tube_bundle_uncertainty(inputs: TubeBundleUncertaintyInput, *, context: Context | None = None) -> CalculationResult[TubeBundleUncertaintyOutput]:
+    'API 581 Annex 2.C.4.1 default tube-bundle inspection uncertainty'
+    return calculate('inspection/tube-bundle-uncertainty', inputs, output_type=TubeBundleUncertaintyOutput, context=context)
+
+
+from ..inspection_effectiveness import AstInspectionEffectiveness as AstEffectivenessInput
+from ..outputs import InspectionAstEffectivenessOutput as AstEffectivenessOutput
+
+def ast_effectiveness(inputs: AstEffectivenessInput, *, context: Context | None = None) -> CalculationResult[AstEffectivenessOutput]:
+    'API 581 Annex 2.C.5 atmospheric storage tank inspection effectiveness category'
+    return calculate('inspection/ast-effectiveness', inputs, output_type=AstEffectivenessOutput, context=context)
+
+
+__all__ = ['equivalent', 'EquivalentInput', 'EquivalentOutput', 'effectiveness_summary', 'EffectivenessSummaryInput', 'EffectivenessSummaryOutput', 'effectiveness_category', 'EffectivenessCategoryInput', 'EffectivenessCategoryOutput', 'thinning_effectiveness', 'ThinningEffectivenessInput', 'ThinningEffectivenessOutput', 'scc_effectiveness', 'SccEffectivenessInput', 'SccEffectivenessOutput', 'external_effectiveness', 'ExternalEffectivenessInput', 'ExternalEffectivenessOutput', 'buried_effectiveness', 'BuriedEffectivenessInput', 'BuriedEffectivenessOutput', 'prd_effectiveness', 'PrdEffectivenessInput', 'PrdEffectivenessOutput', 'lining_effectiveness', 'LiningEffectivenessInput', 'LiningEffectivenessOutput', 'tube_bundle_uncertainty', 'TubeBundleUncertaintyInput', 'TubeBundleUncertaintyOutput', 'ast_effectiveness', 'AstEffectivenessInput', 'AstEffectivenessOutput']

api581/api/level1.py

@@ -0,0 +1,238 @@
+"""Public level1 calculations. Inputs and outputs use named SI units.
+Generated by scripts/build_python_api.py; inspect the request model for fields.
+"""
+from ..core import Context
+from ..result import CalculationResult, calculate
+
+from ..release import Gas as GasInput
+from ..level1_summary import HoleAreas as HoleAreasInput
+from ..release import Liquid as LiquidInput
+from ..level1_toxic import MitigationCredits as MitigationCreditsInput
+from ..level1_toxic import ToxicHoleCase as ToxicHoleCaseInput
+from ..level1_toxic import ToxicMixtureComponentArea as ToxicMixtureComponentAreaInput
+
+from ..consequences import Mitigation as MitigationInput
+from ..outputs import Level1MitigationOutput as MitigationOutput
+
+def mitigation(inputs: MitigationInput, *, context: Context | None = None) -> CalculationResult[MitigationOutput]:
+    'Flammable consequence mitigation factor'
+    return calculate('level1/mitigation', inputs, output_type=MitigationOutput, context=context)
+
+
+from ..consequences import ToxicSource as ToxicSourceInput
+from ..outputs import Level1ToxicSourceOutput as ToxicSourceOutput
+
+def toxic_source(inputs: ToxicSourceInput, *, context: Context | None = None) -> CalculationResult[ToxicSourceOutput]:
+    'Toxic component rate and mass'
+    return calculate('level1/toxic-source', inputs, output_type=ToxicSourceOutput, context=context)
+
+
+from ..consequences import ToxicDuration as ToxicDurationInput
+from ..outputs import Level1ToxicDurationOutput as ToxicDurationOutput
+
+def toxic_duration(inputs: ToxicDurationInput, *, context: Context | None = None) -> CalculationResult[ToxicDurationOutput]:
+    'Toxic release exposure duration'
+    return calculate('level1/toxic-duration', inputs, output_type=ToxicDurationOutput, context=context)
+
+
+from ..consequences import ToxicArea as ToxicAreaInput
+from ..outputs import Level1ToxicAreaOutput as ToxicAreaOutput
+
+def toxic_area(inputs: ToxicAreaInput, *, context: Context | None = None) -> CalculationResult[ToxicAreaOutput]:
+    'Ammonia/chlorine toxic consequence area'
+    return calculate('level1/toxic-area', inputs, output_type=ToxicAreaOutput, context=context)
+
+
+from ..consequences import Steam as SteamAreaInput
+from ..outputs import Level1SteamAreaOutput as SteamAreaOutput
+
+def steam_area(inputs: SteamAreaInput, *, context: Context | None = None) -> CalculationResult[SteamAreaOutput]:
+    'Steam leak personnel consequence area'
+    return calculate('level1/steam-area', inputs, output_type=SteamAreaOutput, context=context)
+
+
+from ..consequences import Acid as AcidCausticAreaInput
+from ..outputs import Level1AcidCausticAreaOutput as AcidCausticAreaOutput
+
+def acid_caustic_area(inputs: AcidCausticAreaInput, *, context: Context | None = None) -> CalculationResult[AcidCausticAreaOutput]:
+    'Acid/caustic splash personnel consequence'
+    return calculate('level1/acid-caustic-area', inputs, output_type=AcidCausticAreaOutput, context=context)
+
+
+from ..level1_toxic import HfH2sCoefficients as HfH2sToxicCoefficientsInput
+from ..outputs import Level1HfH2sToxicCoefficientsOutput as HfH2sToxicCoefficientsOutput
+
+def hf_h2s_toxic_coefficients(inputs: HfH2sToxicCoefficientsInput, *, context: Context | None = None) -> CalculationResult[HfH2sToxicCoefficientsOutput]:
+    'HF/H2S native toxic log-correlation coefficients'
+    return calculate('level1/hf-h2s-toxic-coefficients', inputs, output_type=HfH2sToxicCoefficientsOutput, context=context)
+
+
+from ..level1_toxic import HfH2sArea as HfH2sToxicAreaInput
+from ..outputs import Level1HfH2sToxicAreaOutput as HfH2sToxicAreaOutput
+
+def hf_h2s_toxic_area(inputs: HfH2sToxicAreaInput, *, context: Context | None = None) -> CalculationResult[HfH2sToxicAreaOutput]:
+    'HF/H2S duration-dependent toxic consequence area'
+    return calculate('level1/hf-h2s-toxic-area', inputs, output_type=HfH2sToxicAreaOutput, context=context)
+
+
+from ..level1_toxic import MiscCoefficients as MiscToxicCoefficientsInput
+from ..outputs import Level1MiscToxicCoefficientsOutput as MiscToxicCoefficientsOutput
+
+def misc_toxic_coefficients(inputs: MiscToxicCoefficientsInput, *, context: Context | None = None) -> CalculationResult[MiscToxicCoefficientsOutput]:
+    'Miscellaneous continuous toxic SI coefficients'
+    return calculate('level1/misc-toxic-coefficients', inputs, output_type=MiscToxicCoefficientsOutput, context=context)
+
+
+from ..level1_toxic import MiscArea as MiscToxicAreaInput
+from ..outputs import Level1MiscToxicAreaOutput as MiscToxicAreaOutput
+
+def misc_toxic_area(inputs: MiscToxicAreaInput, *, context: Context | None = None) -> CalculationResult[MiscToxicAreaOutput]:
+    'Ten additional chemical continuous toxic consequence areas'
+    return calculate('level1/misc-toxic-area', inputs, output_type=MiscToxicAreaOutput, context=context)
+
+
+from ..level1_toxic import ToxicCutoff as ToxicCutoffInput
+from ..outputs import Level1ToxicCutoffOutput as ToxicCutoffOutput
+
+def toxic_cutoff(inputs: ToxicCutoffInput, *, context: Context | None = None) -> CalculationResult[ToxicCutoffOutput]:
+    'Historical Level1 toxic concentration screening'
+    return calculate('level1/toxic-cutoff', inputs, output_type=ToxicCutoffOutput, context=context)
+
+
+from ..level1_toxic import ToxicMitigation as ToxicMitigationInput
+from ..outputs import Level1ToxicMitigationOutput as ToxicMitigationOutput
+
+def toxic_mitigation(inputs: ToxicMitigationInput, *, context: Context | None = None) -> CalculationResult[ToxicMitigationOutput]:
+    'Apply explicit toxic source mitigation credits'
+    return calculate('level1/toxic-mitigation', inputs, output_type=ToxicMitigationOutput, context=context)
+
+
+from ..level1_toxic import ToxicComponent as ToxicComponentConsequenceInput
+from ..outputs import Level1ToxicComponentConsequenceOutput as ToxicComponentConsequenceOutput
+
+def toxic_component_consequence(inputs: ToxicComponentConsequenceInput, *, context: Context | None = None) -> CalculationResult[ToxicComponentConsequenceOutput]:
+    'Compose toxic source/duration/mitigation and per-component area'
+    return calculate('level1/toxic-component-consequence', inputs, output_type=ToxicComponentConsequenceOutput, context=context)
+
+
+from ..level1_toxic import ToxicMixtureAreas as ToxicMixtureConsequenceInput
+from ..outputs import Level1ToxicMixtureConsequenceOutput as ToxicMixtureConsequenceOutput
+
+def toxic_mixture_consequence(inputs: ToxicMixtureConsequenceInput, *, context: Context | None = None) -> CalculationResult[ToxicMixtureConsequenceOutput]:
+    'Largest individual Level 1 toxic consequence area for a mixture'
+    return calculate('level1/toxic-mixture-consequence', inputs, output_type=ToxicMixtureConsequenceOutput, context=context)
+
+
+from ..level1_toxic import ToxicHoleSummary as ToxicHoleSummaryInput
+from ..outputs import Level1ToxicHoleSummaryOutput as ToxicHoleSummaryOutput
+
+def toxic_hole_summary(inputs: ToxicHoleSummaryInput, *, context: Context | None = None) -> CalculationResult[ToxicHoleSummaryOutput]:
+    'Four-hole GFF-weighted Level 1 toxic consequence'
+    return calculate('level1/toxic-hole-summary', inputs, output_type=ToxicHoleSummaryOutput, context=context)
+
+
+from ..level1 import Coefficients as FlammableCoefficientsInput
+from ..outputs import Level1FlammableCoefficientsOutput as FlammableCoefficientsOutput
+
+def flammable_coefficients(inputs: FlammableCoefficientsInput, *, context: Context | None = None) -> CalculationResult[FlammableCoefficientsOutput]:
+    'SI flammable consequence coefficients'
+    return calculate('level1/flammable-coefficients', inputs, output_type=FlammableCoefficientsOutput, context=context)
+
+
+from ..level1 import FinalPhase as ReleasePhaseInput
+from ..outputs import Level1ReleasePhaseOutput as ReleasePhaseOutput
+
+def release_phase(inputs: ReleasePhaseInput, *, context: Context | None = None) -> CalculationResult[ReleasePhaseOutput]:
+    'Level 1 final consequence phase'
+    return calculate('level1/release-phase', inputs, output_type=ReleasePhaseOutput, context=context)
+
+
+from ..level1 import Energy as EnergyEfficiencyInput
+from ..outputs import Level1EnergyEfficiencyOutput as EnergyEfficiencyOutput
+
+def energy_efficiency(inputs: EnergyEfficiencyInput, *, context: Context | None = None) -> CalculationResult[EnergyEfficiencyOutput]:
+    'Instantaneous energy efficiency correction'
+    return calculate('level1/energy-efficiency', inputs, output_type=EnergyEfficiencyOutput, context=context)
+
+
+from ..level1 import Blending as BlendingFactorsInput
+from ..outputs import Level1BlendingFactorsOutput as BlendingFactorsOutput
+
+def blending_factors(inputs: BlendingFactorsInput, *, context: Context | None = None) -> CalculationResult[BlendingFactorsOutput]:
+    'Type 0 release/AIT blending factors'
+    return calculate('level1/blending-factors', inputs, output_type=BlendingFactorsOutput, context=context)
+
+
+from ..level1 import Area as FlammableAreaInput
+from ..outputs import Level1FlammableAreaOutput as FlammableAreaOutput
+
+def flammable_area(inputs: FlammableAreaInput, *, context: Context | None = None) -> CalculationResult[FlammableAreaOutput]:
+    'Type 0 per-hole blended flammable consequence'
+    return calculate('level1/flammable-area', inputs, output_type=FlammableAreaOutput, context=context)
+
+
+from ..level1 import ReleaseToFlammable as ReleaseToFlammableInput
+from ..outputs import Level1ReleaseToFlammableOutput as ReleaseToFlammableOutput
+
+def release_to_flammable(inputs: ReleaseToFlammableInput, *, context: Context | None = None) -> CalculationResult[ReleaseToFlammableOutput]:
+    'Compose source, inventory, controls and per-hole flammable area'
+    return calculate('level1/release-to-flammable', inputs, output_type=ReleaseToFlammableOutput, context=context)
+
+
+from ..level1 import ReleaseToAcid as ReleaseToAcidInput
+from ..outputs import Level1ReleaseToAcidOutput as ReleaseToAcidOutput
+
+def release_to_acid(inputs: ReleaseToAcidInput, *, context: Context | None = None) -> CalculationResult[ReleaseToAcidOutput]:
+    'Compose controlled release and ACID splash consequence'
+    return calculate('level1/release-to-acid', inputs, output_type=ReleaseToAcidOutput, context=context)
+
+
+from ..level1 import ReleaseToSteam as ReleaseToSteamInput
+from ..outputs import Level1ReleaseToSteamOutput as ReleaseToSteamOutput
+
+def release_to_steam(inputs: ReleaseToSteamInput, *, context: Context | None = None) -> CalculationResult[ReleaseToSteamOutput]:
+    'Compose controlled release and Level 1 steam consequence'
+    return calculate('level1/release-to-steam', inputs, output_type=ReleaseToSteamOutput, context=context)
+
+
+from ..level1 import ReleaseToToxic as ReleaseToToxicInput
+from ..outputs import Level1ReleaseToToxicOutput as ReleaseToToxicOutput
+
+def release_to_toxic(inputs: ReleaseToToxicInput, *, context: Context | None = None) -> CalculationResult[ReleaseToToxicOutput]:
+    'Compose controlled release and Level 1 toxic consequence'
+    return calculate('level1/release-to-toxic', inputs, output_type=ReleaseToToxicOutput, context=context)
+
+
+from ..level1_summary import Summary as ConsequenceSummaryInput
+from ..outputs import Level1ConsequenceSummaryOutput as ConsequenceSummaryOutput
+
+def consequence_summary(inputs: ConsequenceSummaryInput, *, context: Context | None = None) -> CalculationResult[ConsequenceSummaryOutput]:
+    'Four-hole mechanism-weighted final consequence areas'
+    return calculate('level1/consequence-summary', inputs, output_type=ConsequenceSummaryOutput, context=context)
+
+
+from ..level1_type1 import Type1Area as Type1FlammableAreaInput
+from ..outputs import Level1Type1FlammableAreaOutput as Type1FlammableAreaOutput
+
+def type1_flammable_area(inputs: Type1FlammableAreaInput, *, context: Context | None = None) -> CalculationResult[Type1FlammableAreaOutput]:
+    'Type1 single-effect flammable consequence area'
+    return calculate('level1/type1-flammable-area', inputs, output_type=Type1FlammableAreaOutput, context=context)
+
+
+from ..level1_type1 import Type1Consequence as Type1FlammableConsequenceInput
+from ..outputs import Level1Type1FlammableConsequenceOutput as Type1FlammableConsequenceOutput
+
+def type1_flammable_consequence(inputs: Type1FlammableConsequenceInput, *, context: Context | None = None) -> CalculationResult[Type1FlammableConsequenceOutput]:
+    'Type1 equipment and personnel flammable areas'
+    return calculate('level1/type1-flammable-consequence', inputs, output_type=Type1FlammableConsequenceOutput, context=context)
+
+
+from ..level1_type1 import ReleaseToType1 as ReleaseToType1FlammableInput
+from ..outputs import Level1ReleaseToType1FlammableOutput as ReleaseToType1FlammableOutput
+
+def release_to_type1_flammable(inputs: ReleaseToType1FlammableInput, *, context: Context | None = None) -> CalculationResult[ReleaseToType1FlammableOutput]:
+    'Compose controlled release and Type1 flammable consequence'
+    return calculate('level1/release-to-type1-flammable', inputs, output_type=ReleaseToType1FlammableOutput, context=context)
+
+
+__all__ = ['GasInput', 'HoleAreasInput', 'LiquidInput', 'MitigationCreditsInput', 'ToxicHoleCaseInput', 'ToxicMixtureComponentAreaInput', 'mitigation', 'MitigationInput', 'MitigationOutput', 'toxic_source', 'ToxicSourceInput', 'ToxicSourceOutput', 'toxic_duration', 'ToxicDurationInput', 'ToxicDurationOutput', 'toxic_area', 'ToxicAreaInput', 'ToxicAreaOutput', 'steam_area', 'SteamAreaInput', 'SteamAreaOutput', 'acid_caustic_area', 'AcidCausticAreaInput', 'AcidCausticAreaOutput', 'hf_h2s_toxic_coefficients', 'HfH2sToxicCoefficientsInput', 'HfH2sToxicCoefficientsOutput', 'hf_h2s_toxic_area', 'HfH2sToxicAreaInput', 'HfH2sToxicAreaOutput', 'misc_toxic_coefficients', 'MiscToxicCoefficientsInput', 'MiscToxicCoefficientsOutput', 'misc_toxic_area', 'MiscToxicAreaInput', 'MiscToxicAreaOutput', 'toxic_cutoff', 'ToxicCutoffInput', 'ToxicCutoffOutput', 'toxic_mitigation', 'ToxicMitigationInput', 'ToxicMitigationOutput', 'toxic_component_consequence', 'ToxicComponentConsequenceInput', 'ToxicComponentConsequenceOutput', 'toxic_mixture_consequence', 'ToxicMixtureConsequenceInput', 'ToxicMixtureConsequenceOutput', 'toxic_hole_summary', 'ToxicHoleSummaryInput', 'ToxicHoleSummaryOutput', 'flammable_coefficients', 'FlammableCoefficientsInput', 'FlammableCoefficientsOutput', 'release_phase', 'ReleasePhaseInput', 'ReleasePhaseOutput', 'energy_efficiency', 'EnergyEfficiencyInput', 'EnergyEfficiencyOutput', 'blending_factors', 'BlendingFactorsInput', 'BlendingFactorsOutput', 'flammable_area', 'FlammableAreaInput', 'FlammableAreaOutput', 'release_to_flammable', 'ReleaseToFlammableInput', 'ReleaseToFlammableOutput', 'release_to_acid', 'ReleaseToAcidInput', 'ReleaseToAcidOutput', 'release_to_steam', 'ReleaseToSteamInput', 'ReleaseToSteamOutput', 'release_to_toxic', 'ReleaseToToxicInput', 'ReleaseToToxicOutput', 'consequence_summary', 'ConsequenceSummaryInput', 'ConsequenceSummaryOutput', 'type1_flammable_area', 'Type1FlammableAreaInput', 'Type1FlammableAreaOutput', 'type1_flammable_consequence', 'Type1FlammableConsequenceInput', 'Type1FlammableConsequenceOutput', 'release_to_type1_flammable', 'ReleaseToType1FlammableInput', 'ReleaseToType1FlammableOutput']

api581/api/level2.py

@@ -0,0 +1,74 @@
+"""Public level2 calculations. Inputs and outputs use named SI units.
+Generated by scripts/build_python_api.py; inspect the request model for fields.
+"""
+from ..core import Context
+from ..result import CalculationResult, calculate
+
+from ..cost_tables import ComponentOutage as ComponentOutageInput
+from ..level2_summary import CorrelatedJetPool as Level2_summaryCorrelatedJetPoolInput
+from ..level2_summary import FinancialBasis as FinancialBasisInput
+from ..level2_summary import FlammableOutcome as FlammableOutcomeInput
+from ..level2_summary import FrequencyScenario as FrequencyScenarioInput
+from ..level2_summary import MechanismHole as MechanismHoleInput
+from ..level2_summary import NfntAreas as NfntAreasInput
+from ..cost_tables import RepairCost as RepairCostInput
+from ..level2_summary import ScenarioCase as ScenarioCaseInput
+from ..toxic_level2 import ToxicCloudArea as ToxicCloudAreaInput
+
+from ..level2_summary import CorrelatedJetPool as CorrelatedJetPoolInput
+from ..outputs import Level2CorrelatedJetPoolOutput as CorrelatedJetPoolOutput
+
+def correlated_jet_pool(inputs: CorrelatedJetPoolInput, *, context: Context | None = None) -> CalculationResult[CorrelatedJetPoolOutput]:
+    'One immediate-ignition branch with max(jet,pool) area'
+    return calculate('level2/correlated-jet-pool', inputs, output_type=CorrelatedJetPoolOutput, context=context)
+
+
+from ..level2_summary import FlammableCase as FlammableCaseInput
+from ..outputs import Level2FlammableCaseOutput as FlammableCaseOutput
+
+def flammable_case(inputs: FlammableCaseInput, *, context: Context | None = None) -> CalculationResult[FlammableCaseOutput]:
+    'Flammable areas with optional correlated immediate branch'
+    return calculate('level2/flammable-case', inputs, output_type=FlammableCaseOutput, context=context)
+
+
+from ..level2_summary import FinalArea as FinalAreaInput
+from ..outputs import Level2FinalAreaOutput as FinalAreaOutput
+
+def final_area(inputs: FinalAreaInput, *, context: Context | None = None) -> CalculationResult[FinalAreaOutput]:
+    'Final Level2 component/personnel consequence areas'
+    return calculate('level2/final-area', inputs, output_type=FinalAreaOutput, context=context)
+
+
+from ..level2_summary import ConsequenceSummary as ConsequenceSummaryInput
+from ..outputs import Level2ConsequenceSummaryOutput as ConsequenceSummaryOutput
+
+def consequence_summary(inputs: ConsequenceSummaryInput, *, context: Context | None = None) -> CalculationResult[ConsequenceSummaryOutput]:
+    'GFF mechanism averages followed by Level2 final selection'
+    return calculate('level2/consequence-summary', inputs, output_type=ConsequenceSummaryOutput, context=context)
+
+
+from ..level2_summary import ScenarioCase as ScenarioConsequenceInput
+from ..outputs import Level2ScenarioConsequenceOutput as ScenarioConsequenceOutput
+
+def scenario_consequence(inputs: ScenarioConsequenceInput, *, context: Context | None = None) -> CalculationResult[ScenarioConsequenceOutput]:
+    'One-hole flammable/toxic/NFNT mechanism consequences'
+    return calculate('level2/scenario-consequence', inputs, output_type=ScenarioConsequenceOutput, context=context)
+
+
+from ..level2_summary import ScenarioSummary as ScenarioSummaryInput
+from ..outputs import Level2ScenarioSummaryOutput as ScenarioSummaryOutput
+
+def scenario_summary(inputs: ScenarioSummaryInput, *, context: Context | None = None) -> CalculationResult[ScenarioSummaryOutput]:
+    'Four raw event scenarios to final Level2 consequence areas'
+    return calculate('level2/scenario-summary', inputs, output_type=ScenarioSummaryOutput, context=context)
+
+
+from ..level2_summary import Assessment as AssessmentInput
+from ..outputs import Level2AssessmentOutput as AssessmentOutput
+
+def assessment(inputs: AssessmentInput, *, context: Context | None = None) -> CalculationResult[AssessmentOutput]:
+    'Supplied Level2 event consequences to financial/annual risk'
+    return calculate('level2/assessment', inputs, output_type=AssessmentOutput, context=context)
+
+
+__all__ = ['ComponentOutageInput', 'Level2_summaryCorrelatedJetPoolInput', 'FinancialBasisInput', 'FlammableOutcomeInput', 'FrequencyScenarioInput', 'MechanismHoleInput', 'NfntAreasInput', 'RepairCostInput', 'ScenarioCaseInput', 'ToxicCloudAreaInput', 'correlated_jet_pool', 'CorrelatedJetPoolInput', 'CorrelatedJetPoolOutput', 'flammable_case', 'FlammableCaseInput', 'FlammableCaseOutput', 'final_area', 'FinalAreaInput', 'FinalAreaOutput', 'consequence_summary', 'ConsequenceSummaryInput', 'ConsequenceSummaryOutput', 'scenario_consequence', 'ScenarioConsequenceInput', 'ScenarioConsequenceOutput', 'scenario_summary', 'ScenarioSummaryInput', 'ScenarioSummaryOutput', 'assessment', 'AssessmentInput', 'AssessmentOutput']

api581/api/planning.py

@@ -0,0 +1,17 @@
+"""Public planning calculations. Inputs and outputs use named SI units.
+Generated by scripts/build_python_api.py; inspect the request model for fields.
+"""
+from ..core import Context
+from ..result import CalculationResult, calculate
+
+from ..risk import RiskPoint as RiskPointInput
+
+from ..risk import Crossing as TargetCrossingInput
+from ..outputs import PlanningTargetCrossingOutput as TargetCrossingOutput
+
+def target_crossing(inputs: TargetCrossingInput, *, context: Context | None = None) -> CalculationResult[TargetCrossingOutput]:
+    'First target crossing on a supplied risk curve'
+    return calculate('planning/target-crossing', inputs, output_type=TargetCrossingOutput, context=context)
+
+
+__all__ = ['RiskPointInput', 'target_crossing', 'TargetCrossingInput', 'TargetCrossingOutput']