Implementing Type Guards in Python

Type guards are a crucial concept for writing robust and maintainable Python code, especially when dealing with functions that accept arguments of multiple, potentially incompatible types. This challenge will guide you in implementing type guards to safely narrow down the type of a variable within a specific scope, allowing for more precise and predictable code execution.

Problem Description

You are tasked with creating a system that processes different types of geometric shapes. A single function will receive an object representing a shape, and based on its type, it should perform a specific operation. To do this safely and effectively, you need to implement type guards that can accurately identify the type of shape being passed into the function.

What needs to be achieved: Implement functions that act as "type guards" for different shape types (e.g., Circle, Square). These type guards should return True if the provided argument is of the specified type, and False otherwise.

Key requirements:

1. Define base classes or ABCs for geometric shapes.
2. Implement at least two concrete shape classes (e.g., Circle, Square).
3. Create type guard functions for each concrete shape class.
4. Create a main processing function that uses these type guards to determine the shape and perform a specific action (e.g., calculate area).

Expected behavior:

• When a Circle object is passed to a Circle type guard, it should return True.
• When a Square object is passed to a Circle type guard, it should return False.
• The main processing function should correctly identify the shape and execute the appropriate logic.

Important edge cases to consider:

• What happens if an object of an unknown type is passed to the processing function?
• Consider how to handle subclasses or instances of unrelated types.

Examples

Example 1:

from typing import Union

class Shape:
    pass

class Circle(Shape):
    def __init__(self, radius: float):
        self.radius = radius

class Square(Shape):
    def __init__(self, side_length: float):
        self.side_length = side_length

# Type guard for Circle
def is_circle(shape: object) -> bool:
    # Implementation needed here

# Type guard for Square
def is_square(shape: object) -> bool:
    # Implementation needed here

def process_shape(shape: object):
    if is_circle(shape):
        # Calculate and print area for Circle
        print(f"Processing a Circle with radius {shape.radius}. Area: {3.14159 * shape.radius**2}")
    elif is_square(shape):
        # Calculate and print area for Square
        print(f"Processing a Square with side length {shape.side_length}. Area: {shape.side_length**2}")
    else:
        print("Unknown shape type.")

# --- Usage ---
my_circle = Circle(5.0)
my_square = Square(4.0)
my_list = [1, 2, 3]

process_shape(my_circle)
process_shape(my_square)
process_shape(my_list)

Expected Output:

Processing a Circle with radius 5.0. Area: 78.53975
Processing a Square with side length 4.0. Area: 16.0
Unknown shape type.

Explanation: The process_shape function uses is_circle and is_square to determine the type of the input shape. For my_circle, is_circle returns True, and the circle's area is calculated. For my_square, is_circle returns False, but is_square returns True, and the square's area is calculated. For my_list, both type guards return False, and the "Unknown shape type." message is printed.

Example 2:

# Assume Shape, Circle, Square, is_circle, is_square, and process_shape are defined as in Example 1.

class Rectangle(Shape):
    def __init__(self, width: float, height: float):
        self.width = width
        self.height = height

# Add a new type guard for Rectangle
def is_rectangle(shape: object) -> bool:
    # Implementation needed here

# Modify process_shape to include Rectangle
def process_shape_extended(shape: object):
    if is_circle(shape):
        print(f"Processing a Circle with radius {shape.radius}. Area: {3.14159 * shape.radius**2}")
    elif is_square(shape):
        print(f"Processing a Square with side length {shape.side_length}. Area: {shape.side_length**2}")
    elif is_rectangle(shape):
        print(f"Processing a Rectangle with width {shape.width} and height {shape.height}. Area: {shape.width * shape.height}")
    else:
        print("Unknown shape type.")

# --- Usage ---
my_rectangle = Rectangle(6.0, 3.0)
process_shape_extended(my_rectangle)

Expected Output:

Processing a Rectangle with width 6.0 and height 3.0. Area: 18.0

Explanation: A new Rectangle class and its corresponding type guard is_rectangle are introduced. The process_shape_extended function is updated to recognize and process Rectangle objects, demonstrating the extensibility of the type guard pattern.

Constraints

• The type guard functions should be pure functions; they should not modify the input object.
• The implementation should leverage Python's built-in features for type checking (e.g., isinstance, attribute checking).
• The solution should be efficient and avoid unnecessary overhead for basic type checks.
• Input arguments to the type guard functions can be any Python object.

Notes

Think about how to identify an object as a specific type. isinstance() is a powerful tool for this, but sometimes you might need to check for the presence of specific attributes to confirm a type. Consider using Abstract Base Classes (ABCs) or simple inheritance for a more structured approach to defining your shapes. The typing module in Python offers is_instance_of and other type-hinting related utilities that might be relevant, although for simple type guards, isinstance is often sufficient.