Valuation Approaches API

Cost approach and market approach methods.

Cost Approach

cost_approach

Cost approach valuation methods.

Implements reproduction cost and replacement cost methods from Chapter 3, including obsolescence adjustments.

Classes

CostApproachResult

Bases: BaseModel

Result of a cost approach valuation.

CostInput

Bases: BaseModel

Validated development cost inputs.

ObsolescenceInput

Bases: BaseModel

Validated obsolescence factors.

Functions

reproduction_cost(development_costs: dict, obsolescence_factors: dict | None = None) -> dict

Calculate depreciated reproduction cost of an intangible asset.

Reproduction cost estimates the cost to create an exact replica of the subject asset using the same materials, design, and standards as the original.

Formula

Reproduction Cost = Sum(development_costs) * (1 - total_obsolescence) total_obsolescence = 1 - (1 - functional) * (1 - technological) * (1 - economic)

Parameters:

Name	Type	Description	Default
development_costs	dict	Dict with keys like 'labor', 'materials', 'overhead', etc. Each value must be a non-negative number.	required
obsolescence_factors	dict | None	Optional dict with 'functional', 'technological', 'economic' keys. Values must be between 0 and 1. Defaults to no obsolescence.	None

Returns:

Type	Description
dict	Dict with: - value: Depreciated reproduction cost - method: 'Reproduction Cost' - formula_reference: 'Chapter 3: Cost Approach - Reproduction Cost Method' - gross_cost: Total development cost before obsolescence - total_obsolescence_pct: Combined obsolescence percentage - steps: List of calculation steps - assumptions: Key assumptions used

Raises:

Type	Description
ValueError	If development_costs is empty or contains negative values, or if obsolescence factors are out of range.

Example

result = reproduction_cost( ... {"labor": 400000, "materials": 150000, "overhead": 100000}, ... {"functional": 0.15, "technological": 0.20, "economic": 0.05} ... ) result["value"] 476000.0

Source code in src/approaches/cost_approach.py

def reproduction_cost(
    development_costs: dict,
    obsolescence_factors: dict | None = None,
) -> dict:
    """Calculate depreciated reproduction cost of an intangible asset.

    Reproduction cost estimates the cost to create an exact replica of the
    subject asset using the same materials, design, and standards as the original.

    Formula:
        Reproduction Cost = Sum(development_costs) * (1 - total_obsolescence)
        total_obsolescence = 1 - (1 - functional) * (1 - technological) * (1 - economic)

    Args:
        development_costs: Dict with keys like 'labor', 'materials', 'overhead', etc.
            Each value must be a non-negative number.
        obsolescence_factors: Optional dict with 'functional', 'technological', 'economic'
            keys. Values must be between 0 and 1. Defaults to no obsolescence.

    Returns:
        Dict with:
            - value: Depreciated reproduction cost
            - method: 'Reproduction Cost'
            - formula_reference: 'Chapter 3: Cost Approach - Reproduction Cost Method'
            - gross_cost: Total development cost before obsolescence
            - total_obsolescence_pct: Combined obsolescence percentage
            - steps: List of calculation steps
            - assumptions: Key assumptions used

    Raises:
        ValueError: If development_costs is empty or contains negative values,
            or if obsolescence factors are out of range.

    Example:
        >>> result = reproduction_cost(
        ...     {"labor": 400000, "materials": 150000, "overhead": 100000},
        ...     {"functional": 0.15, "technological": 0.20, "economic": 0.05}
        ... )
        >>> result["value"]
        476000.0
    """
    if not development_costs:
        raise ValueError("development_costs cannot be empty")

    for key, val in development_costs.items():
        if not isinstance(val, (int, float)):
            raise ValueError(f"Cost component '{key}' must be a number, got {type(val).__name__}")
        if val < 0:
            raise ValueError(f"Cost component '{key}' must be non-negative, got {val}")

    gross_cost = sum(development_costs.values())

    steps = [
        f"Sum development costs: {development_costs}",
        f"Gross reproduction cost: ${gross_cost:,.2f}",
    ]

    if obsolescence_factors:
        obs = ObsolescenceInput(**obsolescence_factors)
        combined_retention = (
            (1 - obs.functional) * (1 - obs.technological) * (1 - obs.economic)
        )
        total_obsolescence = 1 - combined_retention
        value = gross_cost * combined_retention

        steps.append(
            f"Apply obsolescence: functional={obs.functional:.1%}, "
            f"technological={obs.technological:.1%}, economic={obs.economic:.1%}"
        )
        steps.append(f"Combined retention factor: {combined_retention:.4f}")
        steps.append(f"Total obsolescence: {total_obsolescence:.1%}")
        steps.append(f"Depreciated reproduction cost: ${value:,.2f}")

        assumptions = [
            "Obsolescence factors are multiplicative (combined retention)",
            "All cost components are in current dollars",
            "Development costs reflect exact reproduction standards",
        ]
    else:
        value = gross_cost
        total_obsolescence = 0.0
        steps.append("No obsolescence adjustments applied")
        assumptions = [
            "Asset is newly created with no obsolescence",
            "All cost components are in current dollars",
        ]

    return {
        "value": value,
        "method": "Reproduction Cost",
        "formula_reference": "Chapter 3: Cost Approach - Reproduction Cost Method",
        "gross_cost": gross_cost,
        "total_obsolescence_pct": total_obsolescence,
        "steps": steps,
        "assumptions": assumptions,
    }

replacement_cost(current_cost: float, obsolescence_factors: dict | None = None) -> dict

Calculate depreciated replacement cost of an intangible asset.

Replacement cost estimates the cost to create an asset with equivalent utility using modern materials, design, and standards (not an exact replica).

Formula

Replacement Cost = current_cost * (1 - total_obsolescence) total_obsolescence = 1 - (1 - functional) * (1 - technological) * (1 - economic)

Parameters:

Name	Type	Description	Default
current_cost	float	Current cost to replace the asset with equivalent utility. Must be non-negative.	required
obsolescence_factors	dict | None	Optional dict with 'functional', 'technological', 'economic' keys. Values must be between 0 and 1. Defaults to no obsolescence.	None

Returns:

Type	Description
dict	Dict with: - value: Depreciated replacement cost - method: 'Replacement Cost' - formula_reference: 'Chapter 3: Cost Approach - Replacement Cost Method' - gross_cost: Current replacement cost before obsolescence - total_obsolescence_pct: Combined obsolescence percentage - steps: List of calculation steps - assumptions: Key assumptions used

Raises:

Type	Description
ValueError	If current_cost is negative or obsolescence factors are out of range.

Example

result = replacement_cost( ... 500000, ... {"functional": 0.10, "technological": 0.30} ... ) result["value"] 315000.0

Source code in src/approaches/cost_approach.py

def replacement_cost(
    current_cost: float,
    obsolescence_factors: dict | None = None,
) -> dict:
    """Calculate depreciated replacement cost of an intangible asset.

    Replacement cost estimates the cost to create an asset with equivalent
    utility using modern materials, design, and standards (not an exact replica).

    Formula:
        Replacement Cost = current_cost * (1 - total_obsolescence)
        total_obsolescence = 1 - (1 - functional) * (1 - technological) * (1 - economic)

    Args:
        current_cost: Current cost to replace the asset with equivalent utility.
            Must be non-negative.
        obsolescence_factors: Optional dict with 'functional', 'technological', 'economic'
            keys. Values must be between 0 and 1. Defaults to no obsolescence.

    Returns:
        Dict with:
            - value: Depreciated replacement cost
            - method: 'Replacement Cost'
            - formula_reference: 'Chapter 3: Cost Approach - Replacement Cost Method'
            - gross_cost: Current replacement cost before obsolescence
            - total_obsolescence_pct: Combined obsolescence percentage
            - steps: List of calculation steps
            - assumptions: Key assumptions used

    Raises:
        ValueError: If current_cost is negative or obsolescence factors are out of range.

    Example:
        >>> result = replacement_cost(
        ...     500000,
        ...     {"functional": 0.10, "technological": 0.30}
        ... )
        >>> result["value"]
        315000.0
    """
    if not isinstance(current_cost, (int, float)):
        raise ValueError(f"current_cost must be a number, got {type(current_cost).__name__}")
    if current_cost < 0:
        raise ValueError(f"current_cost must be non-negative, got {current_cost}")

    steps = [
        f"Current replacement cost: ${current_cost:,.2f}",
    ]

    if obsolescence_factors:
        obs = ObsolescenceInput(**obsolescence_factors)
        combined_retention = (
            (1 - obs.functional) * (1 - obs.technological) * (1 - obs.economic)
        )
        total_obsolescence = 1 - combined_retention
        value = current_cost * combined_retention

        steps.append(
            f"Apply obsolescence: functional={obs.functional:.1%}, "
            f"technological={obs.technological:.1%}, economic={obs.economic:.1%}"
        )
        steps.append(f"Combined retention factor: {combined_retention:.4f}")
        steps.append(f"Total obsolescence: {total_obsolescence:.1%}")
        steps.append(f"Depreciated replacement cost: ${value:,.2f}")

        assumptions = [
            "Obsolescence factors are multiplicative (combined retention)",
            "Current cost reflects modern equivalent utility",
            "Replacement uses current technology and materials",
        ]
    else:
        value = current_cost
        total_obsolescence = 0.0
        steps.append("No obsolescence adjustments applied")
        assumptions = [
            "Asset is newly created with no obsolescence",
            "Current cost reflects modern equivalent utility",
        ]

    return {
        "value": value,
        "method": "Replacement Cost",
        "formula_reference": "Chapter 3: Cost Approach - Replacement Cost Method",
        "gross_cost": current_cost,
        "total_obsolescence_pct": total_obsolescence,
        "steps": steps,
        "assumptions": assumptions,
    }

Market Approach

market_approach

Market approach valuation methods.

Implements comparable transactions and royalty capitalization methods from Chapter 3.

Classes

ComparableInput

Bases: BaseModel

Validated comparable transaction input.

MarketApproachResult

Bases: BaseModel

Result of a market approach valuation.

Functions

market_approach_comparables(comparables: list[dict], subject_revenue: float, adjustments: dict | None = None) -> dict

Valuation based on comparable market transactions.

Applies revenue multiples from comparable transactions to the subject asset's revenue, with optional adjustments for size, risk, or other factors.

Formula

Multiple_i = sale_price_i / revenue_i Adjusted_Multiple_i = Multiple_i * (1 + adjustment_i) Implied_Value_i = Adjusted_Multiple_i * subject_revenue Value = median(Implied_Value_i)

Parameters:

Name	Type	Description	Default
comparables	list[dict]	List of dicts with 'sale_price', 'revenue', 'asset_type' keys. Each comparable must have positive sale_price and revenue.	required
subject_revenue	float	Revenue of the subject asset. Must be positive.	required
adjustments	dict | None	Optional dict mapping comparable index (0-based) to adjustment factor (e.g., {0: 0.10, 1: -0.05}). Defaults to no adjustments.	None

Returns:

Type	Description
dict	Dict with: - value: Median implied value from comparables - method: 'Market Approach - Comparables' - formula_reference: 'Chapter 3: Market Approach - Comparable Transactions' - multiples: List of calculated multiples per comparable - implied_values: List of implied values per comparable - range: (min, max) of implied values - steps: List of calculation steps - assumptions: Key assumptions used

Raises:

Type	Description
ValueError	If comparables is empty, subject_revenue is non-positive, or comparable data is invalid.

Example

comps = [ ... {"sale_price": 5000000, "revenue": 2000000, "asset_type": "trademark"}, ... {"sale_price": 8000000, "revenue": 3000000, "asset_type": "trademark"}, ... {"sale_price": 12000000, "revenue": 4000000, "asset_type": "trademark"}, ... ] result = market_approach_comparables(comps, subject_revenue=2500000) result["value"] 6250000.0

Source code in src/approaches/market_approach.py

def market_approach_comparables(
    comparables: list[dict],
    subject_revenue: float,
    adjustments: dict | None = None,
) -> dict:
    """Valuation based on comparable market transactions.

    Applies revenue multiples from comparable transactions to the subject
    asset's revenue, with optional adjustments for size, risk, or other factors.

    Formula:
        Multiple_i = sale_price_i / revenue_i
        Adjusted_Multiple_i = Multiple_i * (1 + adjustment_i)
        Implied_Value_i = Adjusted_Multiple_i * subject_revenue
        Value = median(Implied_Value_i)

    Args:
        comparables: List of dicts with 'sale_price', 'revenue', 'asset_type' keys.
            Each comparable must have positive sale_price and revenue.
        subject_revenue: Revenue of the subject asset. Must be positive.
        adjustments: Optional dict mapping comparable index (0-based) to
            adjustment factor (e.g., {0: 0.10, 1: -0.05}). Defaults to no adjustments.

    Returns:
        Dict with:
            - value: Median implied value from comparables
            - method: 'Market Approach - Comparables'
            - formula_reference: 'Chapter 3: Market Approach - Comparable Transactions'
            - multiples: List of calculated multiples per comparable
            - implied_values: List of implied values per comparable
            - range: (min, max) of implied values
            - steps: List of calculation steps
            - assumptions: Key assumptions used

    Raises:
        ValueError: If comparables is empty, subject_revenue is non-positive,
            or comparable data is invalid.

    Example:
        >>> comps = [
        ...     {"sale_price": 5000000, "revenue": 2000000, "asset_type": "trademark"},
        ...     {"sale_price": 8000000, "revenue": 3000000, "asset_type": "trademark"},
        ...     {"sale_price": 12000000, "revenue": 4000000, "asset_type": "trademark"},
        ... ]
        >>> result = market_approach_comparables(comps, subject_revenue=2500000)
        >>> result["value"]
        6250000.0
    """
    if not comparables:
        raise ValueError("comparables list cannot be empty")
    if subject_revenue <= 0:
        raise ValueError(f"subject_revenue must be positive, got {subject_revenue}")

    steps = [
        f"Subject asset revenue: ${subject_revenue:,.2f}",
        f"Number of comparables: {len(comparables)}",
    ]

    multiples = []
    implied_values = []

    for i, comp_data in enumerate(comparables):
        comp = ComparableInput(**comp_data)
        multiple = comp.sale_price / comp.revenue

        adjustment = 0.0
        if adjustments and i in adjustments:
            adjustment = adjustments[i]

        adjusted_multiple = multiple * (1 + adjustment)
        implied_value = adjusted_multiple * subject_revenue

        multiples.append(
            {
                "index": i,
                "asset_type": comp.asset_type,
                "sale_price": comp.sale_price,
                "revenue": comp.revenue,
                "multiple": multiple,
                "adjustment": adjustment,
                "adjusted_multiple": adjusted_multiple,
                "implied_value": implied_value,
            }
        )
        implied_values.append(implied_value)

        steps.append(
            f"Comparable {i} ({comp.asset_type}): multiple={multiple:.2f}x, "
            f"adjustment={adjustment:.1%}, implied value=${implied_value:,.2f}"
        )

    sorted_values = sorted(implied_values)
    n = len(sorted_values)
    median_value = (sorted_values[n // 2 - 1] + sorted_values[n // 2]) / 2 if n % 2 == 0 else sorted_values[n // 2]

    steps.append(f"Implied value range: ${min(implied_values):,.2f} - ${max(implied_values):,.2f}")
    steps.append(f"Median implied value: ${median_value:,.2f}")

    assumptions = [
        "Comparable transactions are arm's length and recent",
        "Revenue multiples are appropriate for the asset type",
        "Market conditions are similar between comparables and subject",
        "Adjustments reflect identifiable differences",
    ]

    return {
        "value": median_value,
        "method": "Market Approach - Comparables",
        "formula_reference": "Chapter 3: Market Approach - Comparable Transactions",
        "multiples": multiples,
        "implied_values": implied_values,
        "range": (min(implied_values), max(implied_values)),
        "steps": steps,
        "assumptions": assumptions,
    }

royalty_capitalization(revenue: float, royalty_rate: float, discount_rate: float) -> dict

Valuation using the royalty capitalization method.

Capitalizes a perpetual royalty stream into a present value. Appropriate for mature assets with stable, predictable revenue.

Formula

Value = (revenue * royalty_rate) / discount_rate = annual_royalty / discount_rate

Parameters:

Name	Type	Description	Default
revenue	float	Annual revenue attributable to the asset. Must be positive.	required
royalty_rate	float	Royalty rate as decimal (e.g., 0.04 for 4%). Must be between 0 and 1.	required
discount_rate	float	Discount rate as decimal. Must be positive.	required

Returns:

Type	Description
dict	Dict with: - value: Capitalized royalty value - method: 'Royalty Capitalization' - formula_reference: 'Chapter 3: Market Approach - Royalty Capitalization' - annual_royalty: revenue * royalty_rate - steps: List of calculation steps - assumptions: Key assumptions used

Raises:

Type	Description
ValueError	If inputs are out of valid range.

Example

result = royalty_capitalization( ... revenue=10_000_000, ... royalty_rate=0.04, ... discount_rate=0.15 ... ) result["value"] 2666666.6666666665

Source code in src/approaches/market_approach.py

def royalty_capitalization(
    revenue: float,
    royalty_rate: float,
    discount_rate: float,
) -> dict:
    """Valuation using the royalty capitalization method.

    Capitalizes a perpetual royalty stream into a present value.
    Appropriate for mature assets with stable, predictable revenue.

    Formula:
        Value = (revenue * royalty_rate) / discount_rate
              = annual_royalty / discount_rate

    Args:
        revenue: Annual revenue attributable to the asset. Must be positive.
        royalty_rate: Royalty rate as decimal (e.g., 0.04 for 4%). Must be between 0 and 1.
        discount_rate: Discount rate as decimal. Must be positive.

    Returns:
        Dict with:
            - value: Capitalized royalty value
            - method: 'Royalty Capitalization'
            - formula_reference: 'Chapter 3: Market Approach - Royalty Capitalization'
            - annual_royalty: revenue * royalty_rate
            - steps: List of calculation steps
            - assumptions: Key assumptions used

    Raises:
        ValueError: If inputs are out of valid range.

    Example:
        >>> result = royalty_capitalization(
        ...     revenue=10_000_000,
        ...     royalty_rate=0.04,
        ...     discount_rate=0.15
        ... )
        >>> result["value"]
        2666666.6666666665
    """
    if revenue <= 0:
        raise ValueError(f"revenue must be positive, got {revenue}")
    if not (0 < royalty_rate < 1):
        raise ValueError(f"royalty_rate must be between 0 and 1 (exclusive), got {royalty_rate}")
    if discount_rate <= 0:
        raise ValueError(f"discount_rate must be positive, got {discount_rate}")

    annual_royalty = revenue * royalty_rate
    value = annual_royalty / discount_rate

    steps = [
        f"Annual revenue: ${revenue:,.2f}",
        f"Royalty rate: {royalty_rate:.2%}",
        f"Annual royalty payment: ${annual_royalty:,.2f}",
        f"Discount rate: {discount_rate:.2%}",
        f"Capitalized value: ${value:,.2f}",
    ]

    assumptions = [
        "Revenue is perpetual and stable",
        "Royalty rate reflects arm's length market rate",
        "Discount rate appropriately reflects risk of royalty stream",
        "No growth in revenue is assumed (perpetuity)",
    ]

    return {
        "value": value,
        "method": "Royalty Capitalization",
        "formula_reference": "Chapter 3: Market Approach - Royalty Capitalization",
        "annual_royalty": annual_royalty,
        "steps": steps,
        "assumptions": assumptions,
    }