Your concept feed

class Room:
    def __init__(self, capacity):
        if type(capacity) is not int or capacity < 0:
            raise ValueError("Capacity must be a nonnegative integer")
        self._available = capacity

    @property
    def available(self):
        return self._available

    def book(self, count):
        if type(count) is not int or count <= 0:
            raise ValueError("Booking count must be a positive integer")
        if count > self._available:
            return False
        self._available -= count
        return True

a, b = Room(2), Room(2)
assert not a.book(3) and a.available == 2
assert a.book(1) and a.available == 1
assert b.available == 2
assert not Room(0).book(1)

class Order:
    def __init__(self, items):
        self._items = tuple(items)
        if any(type(price) is not int or price < 0
               or type(quantity) is not int or quantity <= 0
               for price, quantity in self._items):
            raise ValueError("Need nonnegative integer prices and positive quantities")

    def total(self):
        return sum(price * quantity for price, quantity in self._items)

class TextReceipt:
    def render(self, order):
        return f"Total: {order.total()} minor units"

class Checkout:
    def __init__(self, order, renderer):
        self.order = order
        self.renderer = renderer

    def receipt(self):
        return self.renderer.render(self.order)

order = Order([(30, 2), (10, 1)])
assert order.total() == 70
assert Checkout(order, TextReceipt()).receipt() == "Total: 70 minor units"
assert Order([]).total() == 0

from typing import Protocol

class Sender(Protocol):
    def send(self, message: str) -> None: ...

class RecordingSender:
    def __init__(self):
        self.messages = []

    def send(self, message: str) -> None:
        self.messages.append(message)

class Reminder:
    def __init__(self, sender: Sender):
        self.sender = sender

    def send_for(self, name: str) -> None:
        self.sender.send(f"{name}, your saved idea is ready to revisit.")

sender = RecordingSender()
Reminder(sender).send_for("Ana")
assert sender.messages == ["Ana, your saved idea is ready to revisit."]
assert RecordingSender().messages == []

class LegacyClient:
    def __init__(self):
        self.deliveries = []
    def deliver(self, text, priority):
        self.deliveries.append((text, priority))

class SenderAdapter:
    def __init__(self, legacy):
        self.legacy = legacy
    def send(self, message):
        self.legacy.deliver(message, priority="normal")

legacy = LegacyClient()
SenderAdapter(legacy).send("hello")
assert legacy.deliveries == [("hello", "normal")]

class Course:
    def __init__(self, titles):
        self.titles = dict(titles)
    def title(self, lesson_id):
        return self.titles[lesson_id]

class Notebook:
    def __init__(self, notes):
        self.notes = dict(notes)
    def note(self, lesson_id):
        return self.notes.get(lesson_id, "")

class LessonFacade:
    def __init__(self, course, notebook):
        self.course, self.notebook = course, notebook
    def open_lesson(self, lesson_id):
        return {"title": self.course.title(lesson_id),
                "note": self.notebook.note(lesson_id)}

view = LessonFacade(Course({"bfs": "BFS"}), Notebook({})).open_lesson("bfs")
assert view == {"title": "BFS", "note": ""}

from typing import Protocol

class Writer(Protocol):
    def save(self, name: str, content: str) -> None: ...

def render_report(lines):
    return "\n".join(lines)

class MemoryWriter:
    def __init__(self):
        self.reports = {}

    def save(self, name: str, content: str) -> None:
        self.reports[name] = content

class ReportService:
    def __init__(self, writer: Writer):
        self.writer = writer

    def publish(self, name, lines):
        self.writer.save(name, render_report(lines))

store = MemoryWriter()
service = ReportService(store)
service.publish("day", ["A", "B"])
assert store.reports["day"] == "A\nB"
service.publish("day", ["C"])
assert store.reports == {"day": "C"}

def flat_fee(count):
    return 50

def per_item_fee(count):
    return 10 * count

class DeliveryQuote:
    def __init__(self, policy):
        self.policy = policy

    def quote(self, count):
        if type(count) is not int or count < 0:
            raise ValueError("Count must be a nonnegative integer")
        return self.policy(count)

assert DeliveryQuote(flat_fee).quote(3) == 50
assert DeliveryQuote(per_item_fee).quote(3) == 30
assert DeliveryQuote(per_item_fee).quote(0) == 0

class CountingSender:
    def __init__(self, inner):
        self.inner = inner
        self.successes = 0
    def send(self, message):
        self.inner.send(message)
        self.successes += 1

class LocalSender:
    def __init__(self):
        self.messages = []
    def send(self, message):
        if not message:
            raise ValueError("Empty message")
        self.messages.append(message)

wrapped = CountingSender(LocalSender())
wrapped.send("hello")
assert wrapped.successes == 1
try:
    wrapped.send("")
except ValueError:
    pass
assert wrapped.successes == 1

class FlatFee:
    def __init__(self, amount):
        self.amount = amount

    def fee(self, count):
        if type(count) is not int or count < 0:
            raise ValueError("Invalid count")
        return self.amount

class PerItemFee:
    def __init__(self, amount):
        self.amount = amount

    def fee(self, count):
        if type(count) is not int or count < 0:
            raise ValueError("Invalid count")
        return self.amount * count

def make_fee_policy(kind, amount):
    if type(amount) is not int or amount < 0:
        raise ValueError("Invalid amount")
    constructors = {"flat": FlatFee, "per_item": PerItemFee}
    if kind not in constructors:
        raise ValueError("Unknown fee policy")
    return constructors[kind](amount)

assert make_fee_policy("flat", 50).fee(3) == 50
assert make_fee_policy("per_item", 10).fee(3) == 30
try:
    make_fee_policy("mystery", 10)
except ValueError:
    pass
else:
    raise AssertionError("Unknown policy was not rejected")

from dataclasses import dataclass

@dataclass(frozen=True)
class Request:
    method: str
    path: str
    headers: tuple
    timeout: float

class RequestBuilder:
    def __init__(self):
        self.headers = {}
    def header(self, name, value):
        self.headers[name] = value
        return self
    def build(self, method, path, timeout=3):
        if method not in {"GET", "POST"} or not path.startswith("/") or timeout <= 0:
            raise ValueError("Invalid request")
        return Request(method, path, tuple(sorted(self.headers.items())), timeout)

builder = RequestBuilder().header("Accept", "application/json")
request = builder.build("GET", "/ideas")
builder.header("X-New", "yes")
assert request.headers == (("Accept", "application/json"),)
assert request.timeout == 3

from copy import deepcopy

def clone_report(template, title):
    result = deepcopy(template)
    result["title"] = title
    return result

template = {"title": "Base", "columns": ["name", "score"]}
report = clone_report(template, "Today")
report["columns"].append("rank")
assert template["columns"] == ["name", "score"]
assert report["title"] == "Today"

class TextFactory:
    def button(self, label):
        return f"[{label}]"
    def checkbox(self, checked):
        return "[x]" if checked else "[ ]"

class SymbolFactory:
    def button(self, label):
        return f"({label})"
    def checkbox(self, checked):
        return "☑" if checked else "☐"

def render_form(factory):
    return factory.button("Save") + " " + factory.checkbox(True)

assert render_form(TextFactory()) == "[Save] [x]"
assert render_form(SymbolFactory()) == "(Save) ☑"

from abc import ABC, abstractmethod

class Importer(ABC):
    def run(self, values):
        values = list(values)
        if any(type(value) is not int for value in values):
            raise ValueError("Only integers are supported")
        return self.transform(values)

    @abstractmethod
    def transform(self, values):
        pass

class Doubler(Importer):
    def transform(self, values):
        return [2 * value for value in values]

assert Doubler().run([1, 3]) == [2, 6]
assert Doubler().run([]) == []

from abc import ABC, abstractmethod

class TextFormatter:
    def format(self, records):
        return "\n".join(records)

class Exporter(ABC):
    @abstractmethod
    def make_formatter(self):
        pass
    def export(self, records):
        return self.make_formatter().format(records)

class TextExporter(Exporter):
    def make_formatter(self):
        return TextFormatter()

assert TextExporter().export(["a", "b"]) == "a\nb"
assert TextExporter().export([]) == ""

def page_items(fetch):
    cursor = None
    while True:
        items, following = fetch(cursor)
        yield from items
        if following is None:
            return
        if following == cursor:
            raise ValueError("Pagination cursor did not advance")
        cursor = following

pages = {None: (["a", "b"], "second"),
         "second": (["c"], None)}
calls = []
def fetch(cursor):
    calls.append(cursor)
    return pages[cursor]

items = page_items(fetch)
assert next(items) == "a" and calls == [None]
assert list(items) == ["b", "c"]
assert calls == [None, "second"]

class Events:
    def __init__(self):
        self._listeners = {}
        self._next_token = 0

    def subscribe(self, listener):
        token = self._next_token
        self._next_token += 1
        self._listeners[token] = listener
        def unsubscribe():
            self._listeners.pop(token, None)
        return unsubscribe

    def publish(self, event):
        failures = []
        for listener in tuple(self._listeners.values()):
            try:
                listener(event)
            except Exception as error:
                failures.append(error)
        return failures

events, received = Events(), []
stop = events.subscribe(received.append)
assert events.publish("saved") == []
assert received == ["saved"]
stop()
stop()
events.publish("another")
assert received == ["saved"]
def broken(event):
    raise ValueError("Listener rejected event")
events.subscribe(broken)
events.subscribe(received.append)
assert len(events.publish("still delivered")) == 1
assert received[-1] == "still delivered"

class Document:
    def __init__(self, text=""):
        self.text = text

class AppendCommand:
    def __init__(self, document, text):
        self.document, self.text = document, text
        self.executed = False
    def execute(self):
        if self.executed:
            raise ValueError("Command already executed")
        self.before = self.document.text
        self.after = self.before + self.text
        self.document.text = self.after
        self.executed = True
    def undo(self):
        if not self.executed or self.document.text != self.after:
            raise ValueError("Cannot safely undo this command")
        self.document.text = self.before
        self.executed = False

doc = Document("Hi")
command = AppendCommand(doc, "!")
command.execute()
assert doc.text == "Hi!"
command.undo()
assert doc.text == "Hi"

from dataclasses import dataclass

@dataclass(frozen=True)
class Memento:
    owner: object
    text: str

class Document:
    def __init__(self, text=""):
        self.text, self._identity = text, object()
    def snapshot(self):
        return Memento(self._identity, self.text)
    def restore(self, snapshot):
        if snapshot.owner is not self._identity:
            raise ValueError("Wrong document")
        self.text = snapshot.text

doc = Document("before")
saved = doc.snapshot()
doc.text = "after"
doc.restore(saved)
assert doc.text == "before"

class Room:
    def __init__(self):
        self.receivers = {}
    def join(self, name, receiver):
        if name in self.receivers:
            raise ValueError("Duplicate member")
        self.receivers[name] = receiver
    def send(self, sender, text):
        if sender not in self.receivers:
            raise ValueError("Unknown sender")
        for name, receiver in tuple(self.receivers.items()):
            if name != sender:
                receiver((sender, text))

room, ana, bo = Room(), [], []
room.join("Ana", ana.append)
room.join("Bo", bo.append)
room.send("Ana", "hello")
assert ana == [] and bo == [("Ana", "hello")]

def validate(request):
    if not isinstance(request.get("action"), str) or not request["action"]:
        raise ValueError("Missing action")

def authorize(request):
    if request.get("allowed") is not True:
        raise PermissionError("Action denied")

def dispatch(request, handlers, action):
    for handler in handlers:
        handler(request)
    return action(request)

calls = []
result = dispatch({"action": "save", "allowed": True},
                  [validate, authorize], lambda r: calls.append(r["action"]))
assert calls == ["save"]
try:
    dispatch({"action": "save", "allowed": False},
             [validate, authorize], lambda r: calls.append(r["action"]))
except PermissionError:
    pass
assert calls == ["save"]

from enum import Enum, auto

class GateState(Enum):
    LOCKED = auto()
    UNLOCKED = auto()

class Turnstile:
    def __init__(self):
        self._state = GateState.LOCKED

    @property
    def state(self):
        return self._state

    def payment(self):
        if self._state is GateState.UNLOCKED:
            return False
        self._state = GateState.UNLOCKED
        return True

    def push(self):
        if self._state is GateState.LOCKED:
            return False
        self._state = GateState.LOCKED
        return True

gate = Turnstile()
assert not gate.push()
assert gate.payment()
assert not gate.payment()
assert gate.push()
assert gate.state is GateState.LOCKED
assert not gate.push()