hospitality.tronc-allocation

def tronc_allocation(pool: Money, staff: Sequence[TroncMember], method: TroncMethod) -> List[TroncShare]

@dataclass(frozen=True)
class TroncMember:
    """One person in the pool."""

    #: unique within the pool
    id: str
    #: time worked in the period, in minutes
    minutes_worked: int
    #: the member's points under the written tipping policy
    points: int

TroncMethod = Literal["hours", "points", "hours-and-points"]

@dataclass(frozen=True)
class TroncShare:
    """What one person receives."""

    id: str
    #: the number the pool was shared by: minutes, points, or minutes x points
    weight: int
    share: Money

from fune.hospitality.tronc_allocation import tronc_allocation  # hospitality.tronc-allocation@^1

from typing import List, Sequence

from .hospitality_tronc_allocation_types import TroncMember, TroncMethod, TroncShare
from .money_allocate import allocate  ← from money.allocate ^1.0.0 · built alongside by fune
from .money_amount import Money, money  ← from money.amount ^1.0.0 · built alongside by fune


def _whole(value: object) -> bool:
    return isinstance(value, int) and not isinstance(value, bool)


def _weight_of(member: TroncMember, method: str) -> int:
    if method == "hours":
        return member.minutes_worked
    if method == "points":
        return member.points
    if method == "hours-and-points":
        return member.minutes_worked * member.points
    raise ValueError('unknown tronc method "%s"' % (method,))


def tronc_allocation(pool: Money, staff: Sequence[TroncMember], method: TroncMethod) -> List[TroncShare]:
    """Share a tips pool between staff in proportion to a weight.

    Time is in minutes so a 7.5-hour shift is exact. The pool is split with
    money.allocate, so the shares add up to the pool exactly: the leftover
    pennies go to the largest remainders, ties to whoever is listed first.
    """
    if len(staff) == 0:
        raise ValueError("staff must have at least one member")
    if pool.minor < 0:
        raise ValueError("pool must not be negative, received %d" % (pool.minor,))
    ids = set()
    for member in staff:
        if member.id == "":
            raise ValueError("every member needs an id")
        if member.id in ids:
            raise ValueError('staff id "%s" appears twice' % (member.id,))
        ids.add(member.id)
        if not _whole(member.minutes_worked) or member.minutes_worked < 0:
            raise ValueError(
                'minutesWorked must not be negative, received %s for "%s"' % (member.minutes_worked, member.id)
            )
        if not _whole(member.points) or member.points < 0:
            raise ValueError('points must not be negative, received %s for "%s"' % (member.points, member.id))
    weights = [_weight_of(member, method) for member in staff]
    if sum(weights) == 0:
        if pool.minor != 0:
            raise ValueError("nobody in the pool has any weight to share it by")
        return [TroncShare(id=member.id, weight=0, share=money(0, pool.currency)) for member in staff]
    shares = allocate(pool, weights)
    return [TroncShare(id=member.id, weight=weights[i], share=shares[i]) for i, member in enumerate(staff)]

Install

fune build

With that line in your source, in a Python project (language python in fune.project), fune build resolves it and its 2 dependencies, pins them in fune.lock, downloads only the Python package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. Or pin a range in fune.project and build in one step:

fune add hospitality.tronc-allocation

The manifest, vectors and README with only the Python implementation. Install it without the registry with fune add ./hospitality.tronc-allocation-1.0.0-python.fune, or fetch it from a terminal with fune pull hospitality.tronc-allocation@1.0.0:python.

The whole function, every language, is one file too: hospitality.tronc-allocation-1.0.0.fune, 23,042 bytes, sha256 2a06249aa9fe592eb58b2943d4d639adb5cac80e12b5c5743c97efbeab417afe. It installs into a project of any language.

# fune: before hospitality.tronc-allocation

# fune: after hospitality.tronc-allocation

# fune: replace money.allocate in hospitality.tronc-allocation
# fune: replace money.amount in hospitality.tronc-allocation

# fune: step hospitality.tronc-allocation after <n|label>

More from the author

The shares always add up to the pool exactly. The split is `money.allocate`: each person gets their proportional share rounded down, and the pennies left over go one at a time to the largest remainders, ties to whoever is listed first. So the same inputs always give the same split, and nobody's share is nudged by rounding more than a penny.

## Why minutes

Hours are often fractional (a 7.5-hour shift), and a fraction of an hour as a float is exactly the kind of drift this registry avoids. Minutes are whole numbers, and nothing smaller matters for a tronc.

## Edge cases

- Someone with a weight of 0 (no hours, or no points) receives 0. - An empty pool gives everyone 0. A pool with money in it but no weight on anybody is an error, because there is no fair way to split it. - Ids must be unique and not empty; minutes and points must not be negative.

## The law this does not enforce

Since 1 October 2024 the **Employment (Allocation of Tips) Act 2023** (https://www.legislation.gov.uk/ukpga/2023/13/contents), which inserted Part 2B into the Employment Rights Act 1996, requires employers in Great Britain to pass on all tips, gratuities and service charges they control or significantly influence to workers, without deductions other than tax, and to do so fairly. The **Code of Practice on Fair and Transparent Distribution of Tips**, brought into force by SI 2024/831 (https://www.legislation.gov.uk/uksi/2024/831/made; guidance at https://www.gov.uk/government/publications/distributing-tips-fairly-revised-statutory-code-of-practice and https://www.acas.org.uk/tips-and-service-charges), sets out what fair means in practice. A revised draft Code was published on 29 June 2026 and withdrawn on 29 July 2026 pending consultation, so the 2024 Code still applies.

This function does the arithmetic of a policy. It cannot check that the policy is lawful. In particular, the employer is responsible for:

- allocating fairly (ERA 1996 s27D): choosing fair factors and weights and applying them consistently. The Code discusses factors such as role, hours, seniority and performance; - **not** keeping a share for the business. An employer who is an individual and works alongside staff may only take part as the Act and the Code allow; - including agency workers who worked at the venue; - paying tips no later than the end of the month after the month they were paid (s27G); - having a written tipping policy available to workers (s27I), keeping records of the tips and how they were shared for three years, and answering a worker's written request for them within four weeks (s27J); - consulting workers on the tipping policy, a duty the Employment Rights Act 2025 adds. Check what is in force on the date you use this.

Tax and National Insurance on tronc payments (whether a troncmaster scheme takes the payments out of Class 1 NICs) are payroll matters and are not done here.

Files