The OOP System — Python Milestone Project

One object is easy. A system is where your design gets tested. Your goal is to build a library manager, a text-based program that tracks books, members, checkouts, due dates, and returns using classes that cooperate instead of one giant script.

You are practicing the Part III skill: think in objects. The finished system should use classes, inheritance, dunder methods, and at least one decorator, while also using regex for catalog IDs and datetime for due dates.

What you'll build

You will build one menu-driven library manager with these routes:

1: list the catalog.
2: check out an item to a member.
3: return an item.
4: show a short library summary.
7: exit cleanly.

A catalog item is one thing the library can lend, such as a book or audiobook. A loan is the act of assigning an item to a member until a due date. The scaffold is starter code with TODO comments that show where your work belongs. The acceptance criteria are checks you can run yourself to prove each stage works.

The design picture is the house-blueprint idea from OOP: LibraryItem is the base blueprint, and Book and AudioBook are revised blueprints based on it. Library is the front desk that stores items and sends work to the right object.

python — playgroundlive

import re
from datetime import datetime, timedelta
from functools import wraps
from zoneinfo import ZoneInfo

CATALOG_ID_PATTERN = re.compile(r"^LIB-[0-9]{3}$")
LOCAL_ZONE = ZoneInfo("Asia/Kolkata")
TODAY = datetime(2026, 7, 15, 9, 0, tzinfo=LOCAL_ZONE)
LOAN_DAYS = 14

def log_action(method):
  """Decorator starter: print which library action just ran."""
  @wraps(method)
  def wrapper(self, *args, **kwargs):
      result = method(self, *args, **kwargs)
      print(f"action logged: {method.__name__}")
      return result

return wrapper

class LibraryItem:
  """Base class for anything the library can lend."""

def __init__(self, catalog_id, title):
      if not CATALOG_ID_PATTERN.match(catalog_id):
          raise ValueError("catalog IDs must look like LIB-001")
      self.catalog_id = catalog_id
      self.title = title
      self.checked_out_by = None
      self.due_at = None

@property
  def is_available(self):
      return self.checked_out_by is None

@log_action
  def checkout(self, member_name, now=TODAY):
      # TODO: if the item is not available, print who has it and return.
      # TODO: set checked_out_by to member_name.
      # TODO: set due_at to now + timedelta(days=LOAN_DAYS).
      # TODO: print a clear checkout message with the due date.
      print("Build LibraryItem.checkout() here.")

@log_action
  def return_item(self):
      # TODO: if the item is already available, print a friendly message and return.
      # TODO: print who returned it.
      # TODO: clear checked_out_by and due_at.
      print("Build LibraryItem.return_item() here.")

def __str__(self):
      status = "available" if self.is_available else f"due {self.due_at.date()}"
      return f"{self.catalog_id}: {self.title} ({status})"

def __repr__(self):
      return f"{type(self).__name__}({self.catalog_id!r}, {self.title!r})"

class Book(LibraryItem):
  """A printed book with an author and page count."""

def __init__(self, catalog_id, title, author, pages):
      super().__init__(catalog_id, title)
      self.author = author
      self.pages = pages

def __len__(self):
      # TODO: return the number of pages.
      return 0

class AudioBook(LibraryItem):
  """An audiobook with a narrator and running time."""

def __init__(self, catalog_id, title, narrator, minutes):
      super().__init__(catalog_id, title)
      self.narrator = narrator
      self.minutes = minutes

def __len__(self):
      # TODO: return the number of minutes.
      return 0

class Library:
  """Front desk for catalog lookup, checkout, and returns."""

def __init__(self):
      self.items = []

def add_item(self, item):
      self.items.append(item)

def __len__(self):
      return len(self.items)

def __contains__(self, catalog_id):
      return any(item.catalog_id == catalog_id for item in self.items)

def find_by_id(self, catalog_id):
      # TODO: loop over self.items and return the matching item.
      # TODO: return None if no item matches.
      return None

def print_catalog(self):
      if not self.items:
          print("The catalog is empty.")
          return

for item in self.items:
          print(item)

def checkout(self, catalog_id, member_name):
      item = self.find_by_id(catalog_id)
      if item is None:
          print(f"No item found for {catalog_id}.")
          return
      item.checkout(member_name)

def return_item(self, catalog_id):
      item = self.find_by_id(catalog_id)
      if item is None:
          print(f"No item found for {catalog_id}.")
          return
      item.return_item()

def seed_demo_data(library):
  library.add_item(Book("LIB-001", "Python Field Notes", "Ada Stone", 240))
  library.add_item(Book("LIB-002", "Clean Code Journal", "Mina Rao", 180))
  library.add_item(AudioBook("LIB-003", "The Debugging Walk", "Noor Khan", 95))

def print_summary(library):
  available = sum(1 for item in library.items if item.is_available)
  print(f"Items: {len(library)}")
  print(f"Available: {available}")
  print(f"Checked out: {len(library) - available}")

library = Library()
seed_demo_data(library)

print("Object Library Manager")

while True:
  print()
  print("1 - List catalog")
  print("2 - Check out item")
  print("3 - Return item")
  print("4 - Summary")
  print("7 - Exit")

choice = input("Choose 1, 2, 3, 4, or 7: ")

if choice == "1":
      library.print_catalog()
  elif choice == "2":
      catalog_id = input("Catalog ID: ").strip().upper()
      member_name = input("Member name: ").strip()
      library.checkout(catalog_id, member_name)
  elif choice == "3":
      catalog_id = input("Catalog ID: ").strip().upper()
      library.return_item(catalog_id)
  elif choice == "4":
      print_summary(library)
  elif choice == "7":
      print("Goodbye")
      break
  else:
      print("Pick 1, 2, 3, 4, or 7.")

⌘/Ctrl + Enter to run

Checkpoint 1: the object model

Start by making the object blueprints honest. Keep data that belongs to one item inside LibraryItem, and keep catalog-wide behavior inside Library.

Acceptance criteria:

Creating Book("LIB-001", "Python Field Notes", "Ada Stone", 240) works.
Creating an item with "BAD-1" raises ValueError: catalog IDs must look like LIB-001.
item.is_available returns True before checkout.
str(item) shows the catalog ID, title, and status.
repr(item) gives a developer-facing representation that includes the class name.

Checkpoint 2: inheritance and dunder methods

Now make the subclasses earn their place. Book and AudioBook should share lending behavior from LibraryItem, then add their own details.

Acceptance criteria:

Book and AudioBook both inherit checkout() and return_item() from LibraryItem.
len(book) returns the page count.
len(audio_book) returns the minute count.
len(library) returns the number of catalog items.
"LIB-001" in library returns True when that item exists and False when it does not.

Checkpoint 3: checkout, return, and due dates

Build the lending behavior next. This is where objects start cooperating: the menu talks to Library, Library finds one item, and the item updates its own state.

Acceptance criteria:

Route 2 asks for catalog ID and member name.
Checking out an available item stores the member name.
The due date is TODAY + timedelta(days=LOAN_DAYS).
Trying to check out an unavailable item prints who already has it.
Route 3 clears checked_out_by and due_at.
The @log_action decorator runs after checkout and return.

Checkpoint 4: validation and search

Use the text and time tools from Section 13 where they belong. Regex should check catalog ID shape, and datetime should represent due dates.

Acceptance criteria:

find_by_id() returns the matching item object, not a string or dictionary.
Unknown catalog IDs print No item found for LIB-999. or the matching ID.
Catalog IDs are normalized with .strip().upper() before lookup.
Due dates are aware datetimes using ZoneInfo("Asia/Kolkata").
Listing the catalog after a checkout shows the changed status.

Checkpoint 5: test the full system

Walk every route like a user. A project is not done because one happy path worked.

Acceptance criteria:

Entering 7 prints Goodbye and exits.
Route 1 lists all demo items.
Route 4 shows item, available, and checked-out counts.
Checkout followed by catalog listing shows the item as unavailable.
Return followed by summary increases the available count.
The code has no giant route that edits every detail directly; objects own their own behavior.

Stretch goals

Choose one or two after the base system works:

Add a Member class with __str__ and a list of checked-out catalog IDs.
Add a DigitalBook subclass with a download size.
Add a route that lists overdue items by comparing due_at to a fixed aware datetime.
Save and load the catalog in JSON during one page session.
Add a custom class decorator that registers every item type by name.

How to get unstuck

If the class shape gets fuzzy, revisit Thinking in Objects and Classes & Instances. If subclass behavior feels duplicated, go back to Inheritance. If len(item), str(item), or "LIB-001" in library surprises you, rebuild the examples from Special Dunder Methods. If the decorator wrapper gets noisy, compare it to Decorators. If ID validation or due dates fail, return to Regular Expressions and Dates, Times & Time Zones.

Part III is complete when this project feels like a set of cooperating objects, not one long script. Part IV shifts the focus from building programs that work to shaping programs that stay readable, testable, and professional as they grow.