Building a Simple Library Management System with ORM

This challenge focuses on designing and implementing ORM (Object-Relational Mapping) models in Python using SQLAlchemy. You'll be creating models to represent books and authors in a library management system, allowing you to define relationships between them and interact with a database in an object-oriented manner. This exercise will solidify your understanding of ORM principles and database interaction.

Problem Description

You are tasked with creating SQLAlchemy ORM models for a simplified library management system. The system needs to track books and their authors. Each book has a title, publication year, and is written by one or more authors. Each author has a name and can write multiple books.

What needs to be achieved:

Define SQLAlchemy models for Author and Book.
Establish a many-to-many relationship between Author and Book using a join table.
Ensure the models are properly configured for database interaction.

Key Requirements:

The Author model should have an id (primary key, integer), and a name (string).
The Book model should have an id (primary key, integer), a title (string), and a publication_year (integer).
The relationship between Author and Book should be many-to-many, meaning one author can write multiple books, and one book can have multiple authors. This requires a join table (e.g., book_authors) to link authors and books.
Use SQLAlchemy's declarative base to define the models.
The models should be ready to be used with a database engine (though you don't need to create the database or populate it with data in this challenge).

Expected Behavior:

The models should be defined in a way that allows you to:

Create new Author and Book objects.
Associate authors with books.
Query the database to retrieve authors and their books, or books and their authors.

Important Edge Cases to Consider:

Ensure the data types for each field are appropriate (e.g., publication_year should be an integer).
The join table should be properly defined to manage the many-to-many relationship.
Consider how to handle potential errors or constraints (though error handling is not required for this challenge).

Examples

Example 1:

Input: (No direct input, this is about model definition)
Output: (SQLAlchemy model definitions for Author and Book with a many-to-many relationship)
Explanation: The output should be Python code defining the Author and Book classes, inheriting from declarative_base(), with appropriate attributes and a relationship defined using a join table.

Example 2:

Input: (No direct input)
Output: (A correctly defined join table class, e.g., BookAuthors)
Explanation: The join table should have foreign keys referencing both the Author and Book models, and a composite primary key.

Constraints

You must use SQLAlchemy's declarative base for defining the models.
The models should be self-contained and not rely on external data sources or database connections.
The code should be well-formatted and easy to understand.
Focus solely on defining the models; no database creation, population, or querying is required.

Notes

Think about the attributes each model needs to represent the real-world entities (Author and Book).
The many-to-many relationship is crucial. Make sure you understand how to implement it using a join table.
Consider using SQLAlchemy's relationship() function to define the relationship between the models.
This challenge is about the structure of the models, not about interacting with a database. You don't need to write any database connection code.
The id fields are assumed to be auto-incrementing integers.