How to Build a Connection Pool Reuse Mock in Python

import time
from contextlib import contextmanager


class Connection:
    def __init__(self, name):
        self.name = name
        self.in_use = False
        self.busy_since = None

    def fetch(self):
        return f"data from {self.name}"


class ConnectionPool:
    def __init__(self, size=3):
        self.connections = [Connection(f"conn-{i}") for i in range(size)]
        self.metrics = {"acquires": 0, "reuses": 0, "releases": 0}

    @contextmanager
    def get_connection(self):
        conn = self._acquire()
        try:
            yield conn
        finally:
            self._release(conn)

    def _acquire(self):
        # Try to reuse an idle connection first
        for conn in self.connections:
            if not conn.in_use:
                conn.in_use = True
                conn.busy_since = time.time()
                if any(c.in_use for c in self.connections):
                    self.metrics["reuses"] += 1
                self.metrics["acquires"] += 1
                return conn
        # No idle connection — create a new mock connection
        new_conn = Connection(f"conn-{len(self.connections)}")
        new_conn.in_use = True
        new_conn.busy_since = time.time()
        self.connections.append(new_conn)
        self.metrics["acquires"] += 1
        return new_conn

    def _release(self, conn):
        conn.in_use = False
        conn.busy_since = None
        self.metrics["releases"] += 1


if __name__ == "__main__":
    pool = ConnectionPool(size=2)

    with pool.get_connection() as c1:
        print(c1.fetch())
        with pool.get_connection() as c2:
            print(c2.fetch())
        # c1 still in use

    # After exiting first with-block, c1 is free for reuse
    with pool.get_connection() as c3:
        print(c3.fetch())

    print("Metrics:", pool.metrics)