# How AI Berkshire Calculates Valuation Metrics: Command-Line Financial Rigor Explained

> Learn how AI Berkshire calculates valuation metrics like P/E and P/B using its financial rigor command-line tool. Explore single and three-scenario forecasts for in-depth analysis.

- Repository: [Xbt Lin/ai-berkshire](https://github.com/xbtlin/ai-berkshire)
- Tags: how-to-guide
- Published: 2026-07-10

---

**AI Berkshire computes valuation metrics through a dedicated command-line utility [`tools/financial_rigor.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/financial_rigor.py) that calculates P/E, P/B, P/S, EV/EBITDA, and other ratios using the `verify-valuation` sub-command, with optional three-scenario projections for forward-looking analysis.**

The **xbtlin/ai-berkshire** repository implements a systematic approach to valuation metrics calculation through specialized Python utilities designed for rigorous financial analysis. This open-source framework provides automated computation of standard valuation multiples while ensuring safe arithmetic operations and reproducible methodologies across investment research workflows.

## Core Valuation Logic in [`financial_rigor.py`](https://github.com/xbtlin/ai-berkshire/blob/main/financial_rigor.py)

The primary valuation engine resides in [`tools/financial_rigor.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/financial_rigor.py), which exposes the `verify-valuation` sub-command for computing ratios from raw financial inputs.

### The `verify_valuation` Function

At line 98 of [`tools/financial_rigor.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/financial_rigor.py), the `verify_valuation` function processes command-line arguments including **price**, **EPS** (earnings per share), **BVPS** (book value per share), **FCF per share**, **dividend**, and **revenue per share**. It calculates standard multiples including **P/E**, **P/B**, **P/S**, **EV/EBITDA**, **dividend yield**, and **price-to-cash-flow**, returning a structured report of each ratio's computed value.

```bash
python3 tools/financial_rigor.py verify-valuation \
    --price 510 \
    --eps 23.5 \
    --bvps 120 \
    --fcf-per-share 18 \
    --dividend 2.4

```

This command outputs a concise table listing each ratio with its computed value:

| Ratio | Value |
|-------|-------|
| P/E | 21.7x |
| P/B | 4.3x |
| P/S | 8.5x |
| EV/EBITDA | 12.1x |
| Dividend Yield | 2.4% |
| Price-to-Cash-Flow | 28.3x |

### Safe Arithmetic Evaluation

To prevent code injection during calculation, the utility implements a safe evaluation mechanism around line 297 that restricts operations to numeric literals and basic operators only. This **"Safe evaluation"** constraint ensures that input financial figures undergo sanitized arithmetic processing before ratio computation.

## Three-Scenario Valuation Projections

Beyond static calculations, the `three_scenario_valuation` function at line 320 generates forward-looking valuations under **baseline**, **optimistic**, and **pessimistic** assumptions. This multi-scenario approach allows analysts to stress-test valuation plausibility across varying market conditions, providing a range of potential outcomes rather than single-point estimates.

## A-Share Data Integration via [`ashare_data.py`](https://github.com/xbtlin/ai-berkshire/blob/main/ashare_data.py)

For Chinese equity markets, the [`tools/ashare_data.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/ashare_data.py) script provides a high-level wrapper that automates data fetching and valuation computation. The `valuation` parser defined at line 158 accepts a ticker argument (e.g., `600519`) and retrieves the latest price and financial figures before forwarding them to the `verify_valuation` function.

```bash
python3 tools/ashare_data.py valuation 600519

```

This command automatically pulls the required financial data for the specified Chinese A-share and executes the full valuation metrics calculation.

## Embedding Valuation Checks in Research Workflows

The valuation functionality integrates directly into AI Berkshire's research methodologies through skill definitions. Files such as [`skills/investment-team.md`](https://github.com/xbtlin/ai-berkshire/blob/main/skills/investment-team.md), [`skills/portfolio-review.md`](https://github.com/xbtlin/ai-berkshire/blob/main/skills/portfolio-review.md), and [`skills/quality-screen.md`](https://github.com/xbtlin/ai-berkshire/blob/main/skills/quality-screen.md) invoke these tools to embed valuation checks into checklists, portfolio holdings analysis, and screening workflows. This ensures consistent valuation metrics calculation across all analyses conducted by the investment team.

## Summary

- AI Berkshire performs valuation metrics calculation primarily through [`tools/financial_rigor.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/financial_rigor.py) using the `verify-valuation` sub-command.
- The `verify_valuation` function at line 98 computes P/E, P/B, P/S, EV/EBITDA, dividend yield, and price-to-cash-flow from raw financial inputs.
- Safe arithmetic evaluation at line 297 restricts operations to numeric literals and basic operators.
- The `three_scenario_valuation` function at line 320 provides baseline, optimistic, and pessimistic valuation projections.
- [`tools/ashare_data.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/ashare_data.py) offers automated A-share valuation at line 158 by fetching data and invoking the core calculator.
- Research skills embed these tools to ensure reproducible valuation analysis across investment workflows.

## Frequently Asked Questions

### What valuation ratios does AI Berkshire calculate?

AI Berkshire calculates standard multiples including P/E (price-to-earnings), P/B (price-to-book), P/S (price-to-sales), EV/EBITDA, dividend yield, and price-to-cash-flow ratios. These metrics are computed in the `verify_valuation` function within [`tools/financial_rigor.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/financial_rigor.py) from user-provided financial inputs or automatically fetched A-share data.

### How does AI Berkshire ensure safe calculation of valuation metrics?

The repository implements a safe evaluation mechanism around line 297 of [`tools/financial_rigor.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/financial_rigor.py) that restricts arithmetic operations to numeric literals and basic operators only. This prevents code injection while processing external financial data inputs.

### Can AI Berkshire perform scenario-based valuation analysis?

Yes, the `three_scenario_valuation` function at line 320 projects forward-looking valuations under baseline, optimistic, and pessimistic assumptions. This multi-scenario approach helps analysts verify valuation plausibility across different market conditions.

### How do I calculate valuation metrics for a specific Chinese A-share stock?

Use the [`tools/ashare_data.py`](https://github.com/xbtlin/ai-berkshire/blob/main/tools/ashare_data.py) script with the valuation sub-command, passing the ticker symbol as an argument. For example, `python3 tools/ashare_data.py valuation 600519` fetches the latest financial data for that ticker and automatically computes all valuation ratios through the underlying `verify_valuation` function.