Generating a Comprehensive Bond Risk Report

Welcome to the final lesson of our course on bond mathematics. We've built a powerful analytical foundation over the previous lessons, culminating in the creation of a BondAnalytics Python class that can compute all the essential risk metrics for a fixed-income security.

In our last session, we bundled all our calculations into a class and created a get_risk_profile method that produced a dictionary of results. Today, we will complete our journey by focusing on the final, crucial step: presentation. Our objective is to develop a report function that outputs the complete risk profile for any given bond in a structured, professional format. We will refine our class design and build a function that transforms our raw data into a clear, human-readable report, suitable for any risk management or portfolio analysis context.

This lesson serves as the capstone, integrating everything you've learned into a polished, practical, and reusable tool.

1. The Final Metric: PVBP / DV01 in Practice

Before we build the report, let's briefly solidify our understanding of the last metric we added: the Price Value of a Basis Point (PVBP), also known as the Dollar Value of a Basis Point (DV01). While Modified Duration tells us the percentage price change for a 100 basis point (1%) change in yield, PVBP gives us something more direct: the absolute change in the bond's price, in dollar terms, for a one basis point (0.01%) change in yield.

This makes PVBP an extremely practical tool for traders and portfolio managers to quickly gauge the dollar risk of their positions.

As you saw in the reading, the relationship is straightforward. PVBP is derived directly from Modified Duration and the bond's price:

This formula simply scales the percentage sensitivity (Modified Duration) by the bond's price to get a dollar sensitivity, and then divides by 10,000 to move from a 100-basis-point change to a 1-basis-point change. This is the final calculated analytic we will include in our report.

2. Refactoring for Better Design: Separating Logic and Presentation

In our previous lesson, the get_risk_profile method returned a dictionary with pre-formatted strings (e.g., "Yield to Maturity (YTM)": f"{ytm:.4%}"). While convenient for immediate printing, this mixes calculation logic with presentation details, which is not ideal from a software design perspective. A better approach is to have methods return raw numerical data, which can then be used by other systems or formatted by a dedicated presentation function.

Let's refactor our BondAnalytics class. The core calculation methods remain the same, but we will adjust the get_risk_profile method to return a dictionary of raw float values.

Here is the refined get_risk_profile method:

    def get_risk_profile_data(self) -> dict:
        """
        Consolidates all key analytics into a dictionary of raw numerical data.
        
        Returns:
            dict: A dictionary containing the bond's raw analytics data.
        """
        profile_data = {
            "ytm": self.calculate_ytm(),
            "macaulay_duration": self.macaulay_duration(),
            "modified_duration": self.modified_duration(),
            "convexity": self.convexity(),
            "pvbp": self.pvbp(),
        }
        return profile_data

This change makes our class more modular and powerful. The raw data can now be fed into a plotting library, a risk aggregation engine, or, as we'll do next, a dedicated reporting function.

3. Developing the Report Function

Now we can build a function that takes an instance of our BondAnalytics class, retrieves the raw data, and formats it into a polished, structured report printed to the console. This directly fulfills our learning objective.

We will use Python's string formatting capabilities to create a clean, table-like output. This function will exist outside the class, purely for presentation purposes.

def generate_bond_report(bond: 'BondAnalytics'):
    """
    Generates and prints a structured risk profile report for a bond.

    Args:
        bond (BondAnalytics): An instance of the BondAnalytics class.
    """
    



    # Get the calculated data
    analytics = bond.get_risk_profile_data()




    # --- Print the Report ---
    width = 45
    print("=" * width)
    print("|" + "Bond Risk Profile Report".center(width - 2) + "|")
    print("=" * width)
    



    # Input Parameters
    print("|" + "Input Parameters".center(width - 2) + "|")
    print("-" * width)
    print(f"| {'Face Value':<20} | ${bond.fv: >18,.2f} |")
    print(f"| {'Annual Coupon Rate':<20} | {bond.c: >18.2%} |")
    print(f"| {'Years to Maturity':<20} | {bond.n: >18} |")
    print(f"| {'Coupon Frequency':<20} | {bond.m: >18} |")
    print(f"| {'Market Price':<20} | ${bond.price: >18,.2f} |")
    print("-" * width)




    # Calculated Analytics
    print("|" + "Calculated Analytics".center(width - 2) + "|")
    print("-" * width)
    print(f"| {'YTM':<20} | {analytics['ytm']: >18.4%} |")
    print(f"| {'Macaulay Duration':<20} | {analytics['macaulay_duration']: >18.4f} yrs |")
    print(f"| {'Modified Duration':<20} | {analytics['modified_duration']: >18.4f} yrs |")
    print(f"| {'Convexity':<20} | {analytics['convexity']: >18.4f} |")
    print(f"| {'PVBP (DV01)':<20} | ${analytics['pvbp']: >18.4f} |")
    print("=" * width)

This function creates a much more professional and readable output than simply printing a dictionary. The use of .ljust(), .rjust(), and formatted f-strings aligns the data neatly, making it easy to interpret at a glance.

4. The Complete Toolkit

Let's put everything together. Here is the final, complete code for our BondAnalytics class and the generate_bond_report function. This represents the culmination of all the theory and implementation we've covered in the course.

import numpy as np




# --- The Analytics Class (Computation) ---

class BondAnalytics:
    """
    A class to calculate key analytics for a plain vanilla bond.
    """
    def __init__(self, fv: float, c: float, n: int, m: int, price: float):
        self.fv = fv
        self.c = c
        self.n = n
        self.m = m
        self.price = price
        self._times = np.arange(1, self.n * self.m + 1) / self.m
        self._cashflows = self._get_cashflows()
        self._ytm = None

    def _get_cashflows(self):
        coupon_payment = self.c / self.m * self.fv
        cashflows = np.full(self.n * self.m, coupon_payment)
        cashflows[-1] += self.fv
        return cashflows

    def price_from_ytm(self, ytm: float) -> float:
        discount_factors = (1 + ytm / self.m) ** (-self._times * self.m)
        return np.sum(self._cashflows * discount_factors)

    def calculate_ytm(self, accuracy=1e-6, max_iterations=100) -> float:
        if self._ytm is not None:
            return self._ytm
        low_r, high_r = 0.0, 1.0
        for _ in range(max_iterations):
            ytm_guess = (low_r + high_r) / 2
            price_guess = self.price_from_ytm(ytm_guess)
            if abs(price_guess - self.price) < accuracy:
                self._ytm = ytm_guess
                return self._ytm
            if price_guess > self.price:
                low_r = ytm_guess
            else:
                high_r = ytm_guess
        self._ytm = (low_r + high_r) / 2
        return self._ytm

    def macaulay_duration(self) -> float:
        ytm = self.calculate_ytm()
        pv_cashflows = self._cashflows / ((1 + ytm / self.m)**(self._times * self.m))
        weighted_time = np.sum(self._times * pv_cashflows)
        return weighted_time / self.price

    def modified_duration(self) -> float:
        ytm = self.calculate_ytm()
        mac_dur = self.macaulay_duration()
        return mac_dur / (1 + ytm / self.m)

    def convexity(self) -> float:
        ytm = self.calculate_ytm()
        sum_term = np.sum( (self._cashflows / ((1 + ytm/self.m)**(self._times * self.m))) * (self._times*self.m) * (self._times*self.m + 1) )
        convexity_val = sum_term / (self.price * self.m**2 * (1 + ytm/self.m)**2)
        return convexity_val
        
    def pvbp(self) -> float:
        return self.price * self.modified_duration() * 0.0001
    
    def get_risk_profile_data(self) -> dict:
        profile_data = {
            "ytm": self.calculate_ytm(),
            "macaulay_duration": self.macaulay_duration(),
            "modified_duration": self.modified_duration(),
            "convexity": self.convexity(),
            "pvbp": self.pvbp(),
        }
        return profile_data


```grasp
{
  "type": "exercise",
  "id": "550084c8-1a5d-419e-bf5c-d38a0c407220"
}