Skip to content
Simon Mak | Ascent Partners | GitHub

Valuation Approaches API

Cost approach and market approach methods.

Cost Approach

intangible_valuation.approaches.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.

Source code in src/intangible_valuation/approaches/cost_approach.py 
13
14
15
16
17
18
19
20
21
22
class CostApproachResult(BaseModel):
    """Result of a cost approach valuation."""

    value: float = Field(..., description="Estimated value after obsolescence adjustments")
    method: str = Field(..., description="Valuation method name")
    formula_reference: str = Field(..., description="Reference to formula in textbook")
    gross_cost: float = Field(..., description="Total cost before obsolescence")
    total_obsolescence_pct: float = Field(default=0.0, description="Combined obsolescence percentage")
    steps: list[str] = Field(default_factory=list, description="Calculation steps")
    assumptions: list[str] = Field(default_factory=list, description="Key assumptions")

CostInput

Bases: BaseModel

Validated development cost inputs.

Source code in src/intangible_valuation/approaches/cost_approach.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
class CostInput(BaseModel):
    """Validated development cost inputs."""

    labor: float = Field(..., ge=0, description="Labor costs")
    materials: float = Field(..., ge=0, description="Material costs")
    overhead: float = Field(..., ge=0, description="Overhead costs")

    @field_validator("labor", "materials", "overhead")
    @classmethod
    def non_negative(cls, v: float) -> float:
        if v < 0:
            raise ValueError(f"Cost component must be non-negative, got {v}")
        return v

ObsolescenceInput

Bases: BaseModel

Validated obsolescence factors.

Source code in src/intangible_valuation/approaches/cost_approach.py 
40
41
42
43
44
45
class ObsolescenceInput(BaseModel):
    """Validated obsolescence factors."""

    functional: float = Field(default=0.0, ge=0, le=1, description="Functional obsolescence (0-1)")
    technological: float = Field(default=0.0, ge=0, le=1, description="Technological obsolescence (0-1)")
    economic: float = Field(default=0.0, ge=0, le=1, description="Economic obsolescence (0-1)")

Functions

reproduction_cost(development_costs, obsolescence_factors=None)

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
ValuationResult

ValuationResult 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/intangible_valuation/approaches/cost_approach.py 
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
def reproduction_cost(
    development_costs: dict,
    obsolescence_factors: dict | None = None,
) -> ValuationResult:
    """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:
        ValuationResult 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 ValuationResult(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, obsolescence_factors=None)

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
ValuationResult

ValuationResult 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/intangible_valuation/approaches/cost_approach.py 
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
def replacement_cost(
    current_cost: float,
    obsolescence_factors: dict | None = None,
) -> ValuationResult:
    """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:
        ValuationResult 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 ValuationResult(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

intangible_valuation.approaches.market_approach

Market approach valuation methods.

Implements comparable transactions and royalty capitalization methods from Chapter 3.

Classes

MarketApproachResult

Bases: BaseModel

Result of a market approach valuation.

Source code in src/intangible_valuation/approaches/market_approach.py 
13
14
15
16
17
18
19
20
class MarketApproachResult(BaseModel):
    """Result of a market approach valuation."""

    value: float = Field(..., description="Estimated value")
    method: str = Field(..., description="Valuation method name")
    formula_reference: str = Field(..., description="Reference to formula in textbook")
    steps: list[str] = Field(default_factory=list, description="Calculation steps")
    assumptions: list[str] = Field(default_factory=list, description="Key assumptions")

ComparableInput

Bases: BaseModel

Validated comparable transaction input.

Source code in src/intangible_valuation/approaches/market_approach.py 
23
24
25
26
27
28
class ComparableInput(BaseModel):
    """Validated comparable transaction input."""

    sale_price: float = Field(..., gt=0, description="Transaction sale price")
    revenue: float = Field(..., gt=0, description="Revenue associated with the asset")
    asset_type: str = Field(..., min_length=1, description="Type of intangible asset")

Functions

market_approach_comparables(comparables, subject_revenue, adjustments=None)

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
ValuationResult

ValuationResult 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/intangible_valuation/approaches/market_approach.py 
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
def market_approach_comparables(
    comparables: list[dict],
    subject_revenue: float,
    adjustments: dict | None = None,
) -> ValuationResult:
    """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:
        ValuationResult 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 ValuationResult(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, royalty_rate, discount_rate)

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
ValuationResult

ValuationResult 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/intangible_valuation/approaches/market_approach.py 
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
def royalty_capitalization(
    revenue: float,
    royalty_rate: float,
    discount_rate: float,
) -> ValuationResult:
    """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:
        ValuationResult 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 ValuationResult(value=value, method="Royalty Capitalization", formula_reference="Chapter 3: Market Approach - Royalty Capitalization", annual_royalty=annual_royalty, steps=steps, assumptions=assumptions)
Simon Mak Ascent Partners GitHub LinkedIn