Repository Pattern and How to Use it in Python

A practical example

from abc import ABC, abstractmethod
from sqlmodel import SQLModel, create_engine, Session, Field, select
# Define the model
class Item(SQLModel, table=True):
id: int = Field(default=None, primary_key=True)
name: str
# Repository Interface
class IRepository(ABC):
@abstractmethod
def add(self, item: Item):
pass
@abstractmethod
def get(self, name: str) -> Item | None:
pass
# SQLModel implementation
class SQLModelRepository(IRepository):
def __init__(self, db_string="sqlite:///todo.db"):
self.engine = create_engine(db_string)
SQLModel.metadata.create_all(self.engine)
self.session = Session(self.engine)
def add(self, item: Item):
self.session.add(item)
self.session.commit()
def get(self, name: str) -> Item | None:
statement = select(Item).where(Item.name == name)
return self.session.exec(statement).first()
# CSV implementation
class CsvRepository(IRepository):
def __init__(self, file_path="todo.csv"):
self._file_path = file_path
def add(self, item: Item):
with open(self._file_path, "a") as f:
f.write(f"{item.id},{item.name}\n")
def get(self, name: str) -> Item | None:
with open(self._file_path, "r") as f:
return next(
(
Item(id=int(id_str), name=item_name)
for line in f
if (id_str := line.strip().split(",", 1)[0])
and (item_name := line.strip().split(",", 1)[1]) == name
),
None,
)
if __name__ == "__main__":
repo = SQLModelRepository()
repo.add(Item(name="Buy Milk"))
sql_item = repo.get("Buy Milk")

# Swap out the repository implementation
csv_repo = CsvRepository()
csv_repo.add(Item(id=1, name="Buy Milk"))
csv_item = csv_repo.get("Buy Milk")
print(f"{sql_item=}, {csv_item=}, {sql_item == csv_item=}")
# outputs:
# sql_item=Item(name='Buy Milk', id=1), csv_item=Item(id=1, name='Buy Milk'), sql_item == csv_item=True

Let me further explain the code:

• To structure our data, we utilized the SQLModel library to define our Item model. While other Object-Relational Mappers (ORMs) like SQLAlchemy are viable options, SQLModel offers a more streamlined approach that I personally find easier to work with. Additionally, its seamless integration with Pydantic simplifies data validation and serialization.
  
• To establish a consistent structure for data access, we define an IRepository interface. This interface, implemented using Python's Abstract Base Classes (ABCs) and the @abstractmethod decorator, mandates the presence of add and get methods for any class that inherits from it. This approach enforces a contract, ensuring that all repository classes adhere to the same interface despite potential variations in their underlying storage mechanisms. By requiring the implementation of these essential methods, we prevent inconsistencies and promote maintainability within our data access layer.
  
• To accommodate various storage options, we employ the Interface Segregation Principle. An IRepository interface defines essential methods like add and get. Concrete implementations, such as SQLModelRepository and CsvRepository, inherit from IRepository and provide specific data access logic. SQLModelRepository leverages the SQLModel library to interact with a SQLite database, while CsvRepository handles data within a CSV file. This approach allows for interchangeable storage backends while maintaining a consistent API for data interaction.
  
• Finally, to illustrate the application of the repository pattern, we will implement the addition of an item to both SQL and CSV data storage mechanisms. Subsequently, we will showcase the retrieval of this newly added item from both repositories.

Note: for the sake of brevity and clarity in this demonstration, we have omitted explicit error handling mechanisms. In a production environment, robust error handling is important. This includes carefully managing potential issues such as database connectivity problems or file access failures. Implementing proper error handling ensures that the program can recover from unexpected situations and provide informative messages to the user or system administrator.

This illustrative example demonstrates how the repository pattern can be effectively applied in Python. A key benefit of this approach is increased design flexibility. By abstracting data access, we can easily switch between different data storage methods (e.g., databases, files) without impacting the core business logic. This enhances code testability and maintainability.

Have you implemented the repository pattern in your own projects? I will like to know about your experiences in the comments section below.

You may like:

How to identify and fix most common Python errors Like a Pro

A Comprehensive Guide To Understanding Important Python Concepts For Beginners

Introduction to Python Programming