"""Draws a monthly payslip: a letterhead, the employee it names, an earnings table, a dense table of contributions, and the cumulative figures a payslip carries. The Python twin of the `write_payslip` example in Rust. The document is a table before it is anything else: every contribution line is a base, a rate for the employee and a rate for the employer, and the amount each rate comes to; the section headings are rows that span the whole grid; and the totals are boxed off it. Every figure on the page is worked out from the earnings above it, so the sums can be checked with a pencil. Every word the page draws is held in `Words`, once per language, and `HQF_PDF_LANG` picks which one is drawn. The figures, the rates, the ceiling and the employee's name and staff number are the same in both. Usage: python examples/write_payslip.py [out.pdf] [font.ttf] HQF_PDF_LANG=fr python examples/write_payslip.py [out.pdf] """ from __future__ import annotations import math from dataclasses import dataclass from pathlib import Path import _language import _licence import _out import hqf_pdf # A4, in points, and the page's left edge with its mirrored right. PAGE_WIDTH = 595.276 PAGE_HEIGHT = 841.89 LEFT = 56.0 RIGHT = PAGE_WIDTH - LEFT TABLE_WIDTH = PAGE_WIDTH - 2 * LEFT # The ink the headings and rules are drawn in, and the grey of the small print. ACCENT = hqf_pdf.Rgb(0.11, 0.33, 0.55) MUTED = hqf_pdf.Rgb(0.42, 0.42, 0.45) INK = hqf_pdf.Rgb(0.1, 0.1, 0.12) # The logo the letterhead carries: the committed fixture, so the example runs on any # machine. It stands in for the employer's mark. LOGO = Path(__file__).resolve().parents[2] / "hqf-pdf" / "tests" / "images" / "hqf_development.png" # Who the payslip is for. EMPLOYEE_NAME = "Marion Delacroix" EMPLOYEE_ID = "EMP-0231" # What a quantity of one is counted in: hours, days, or nothing at all, in which case # the quantity stands on its own. HOUR = "hour" DAY = "day" BARE = "bare" @dataclass(frozen=True) class Earning: """One line of pay, apart from what it is called: a quantity of ``unit``, each worth ``unit_rate``. The figures read the same whatever language the page is set in. """ quantity: float unit: str unit_rate: float # What the month pays, before anything is taken off it, in the order ``Words.earnings`` # names them. EARNINGS = [ Earning(151.67, HOUR, 27.0), Earning(6.0, HOUR, 33.75), Earning(5.0, DAY, 40.0), Earning(1.0, BARE, 150.0), ] # Which figure a contribution is worked out from: the whole of the gross pay, gross pay # as far as the monthly social security ceiling, the part above that ceiling, or the # part social surcharges are levied on. GROSS = "gross" CAPPED = "capped" UPPER_BAND = "upper band" SURCHARGE = "surcharge" @dataclass(frozen=True) class Section: """A heading over the contributions that follow it.""" @dataclass(frozen=True) class Charge: """A contribution, in percent of its base, apart from what it is called. ``deducted`` is the rate taken out of the employee's pay and ``charged`` the rate the employer pays on top. ``non_deductible`` says whether the employee's share stays inside taxable pay. """ base: str deducted: float charged: float non_deductible: bool = False # The contributions the month is charged, in the order ``Words.lines`` names them. LINES = [ Section(), Charge(GROSS, 0.0, 7.0), Charge(GROSS, 0.75, 1.25), Charge(GROSS, 0.5, 0.0), Section(), Charge(CAPPED, 6.9, 8.55), Charge(GROSS, 0.4, 1.9), Charge(CAPPED, 3.15, 4.72), Charge(UPPER_BAND, 8.64, 12.95), Charge(CAPPED, 0.86, 1.29), Charge(UPPER_BAND, 1.08, 1.62), Section(), Charge(GROSS, 0.0, 5.25), Charge(GROSS, 0.0, 4.05), Charge(GROSS, 0.0, 0.15), Section(), Charge(GROSS, 0.0, 1.1), Charge(GROSS, 0.0, 0.3), Charge(GROSS, 0.0, 0.68), Charge(GROSS, 0.0, 1.0), Section(), Charge(SURCHARGE, 6.8, 0.0), Charge(SURCHARGE, 2.9, 0.0, non_deductible=True), ] # The monthly social security ceiling the capped and upper bands are cut at, the share # of gross pay the social surcharges are levied on, and the rate income tax is withheld # at, as told to the employer by the revenue. CEILING = 3925.0 SURCHARGE_SHARE = 0.9825 TAX_RATE = 11.2 # How many months of the year the cumulative column adds up, this one included. Every # month of the year runs to the same figures. MONTHS = 7.0 # The paid leave the employee stands at, in days. LEAVE_EARNED = 27.5 LEAVE_TAKEN = 12.0 @dataclass(frozen=True) class Words: """Every word the page draws, in one language. What is not language stays out of it: the figures, the rates, the ceiling and the employee's name and staff number are drawn from constants of their own and read the same in every language. """ # The words the document's title is built from, the month it covers, and the word # set large at the head of the page. payslip: str month: str heading: str # What stands before the month the page covers, and that month written out as this # language writes a span of days. period_label: str period: str # What stands before the day the pay was transferred, and that day. paid_label: str pay_date: str # The heading over the employee, what the employee does, and what stands before the # staff number and before the day they joined. employee: str role: str staff_label: str joined_label: str joined_date: str # The heading over what is paid, and the line under the figure. net_paid: str transferred: str # What an hour and a day are written as after a quantity. hour: str day: str # The four column headings of the earnings table. earnings_heading: str quantity: str unit_rate: str earnings_amount: str # What each line of pay is called, in the order ``EARNINGS`` pays them, and the # total under them. earnings: tuple[str, str, str, str] gross_pay: str # The two tiers of headings of the contributions table. employee_share: str employer_share: str contribution: str base: str rate: str amount: str # What each row of the contributions table is called, in the order ``LINES`` sets # them, headings included. lines: tuple[str, ...] # The three totals under the contributions. total_contributions: str net_before_tax: str total_cost: str # The three column headings of the cumulative table, the five lines it carries, and # what is paid over at the foot of it. summary: str this_month: str year_to_date: str summary_lines: tuple[str, str, str, str, str] net_paid_row: str # The heading over the leave, and the three counts under it. leave: str leave_earned: str leave_taken: str leave_remaining: str # The working week, and the small print at the foot of the page. working_time: str mentions: str def unit(self, unit: str) -> str: """What a quantity is counted in, in this language.""" if unit == HOUR: return self.hour if unit == DAY: return self.day return "" # The payslip in English. ENGLISH = Words( payslip="Payslip", month="July 2026", heading="PAYSLIP", period_label="Period", period="1 – 31 July 2026", paid_label="Paid on", pay_date="31 July 2026", employee="EMPLOYEE", role="Senior software engineer — grade 3.2", staff_label="Staff No.", joined_label="Joined", joined_date="4 September 2023", net_paid="NET PAID", transferred="Transferred to the account on file", hour="h", day="d", earnings_heading="Earnings", quantity="Quantity", unit_rate="Unit rate", earnings_amount="Amount", earnings=( "Monthly base salary", "Overtime, first eight hours (125 %)", "On-call cover, weekend", "Seniority bonus", ), gross_pay="GROSS PAY", employee_share="Employee share", employer_share="Employer share", contribution="Contribution", base="Base", rate="Rate", amount="Amount", lines=( "HEALTH, MATERNITY, DISABILITY, DEATH", "Health and maternity insurance", "Supplementary health cover", "Daily sickness allowance", "RETIREMENT", "State pension, capped", "State pension, uncapped", "Supplementary pension, band 1", "Supplementary pension, band 2", "Balancing contribution, band 1", "Balancing contribution, band 2", "FAMILY AND UNEMPLOYMENT", "Family allowances", "Unemployment insurance", "Wage guarantee scheme", "OTHER EMPLOYER CONTRIBUTIONS", "Workplace accident cover", "Autonomy solidarity contribution", "Apprenticeship levy", "Continuing training levy", "SOCIAL SURCHARGES", "Social surcharge, deductible", "Social surcharge and debt levy, non-deductible", ), total_contributions="TOTAL CONTRIBUTIONS", net_before_tax="NET PAY BEFORE INCOME TAX", total_cost="TOTAL COST OF THE MONTH TO THE EMPLOYER", summary="Summary", this_month="This month", year_to_date="Year to date", summary_lines=( "Gross pay", "Employee contributions", "Employer contributions", "Taxable pay", "Income tax withheld at 11.20 %", ), net_paid_row="NET PAID", leave="PAID LEAVE", leave_earned="Earned this year", leave_taken="taken", leave_remaining="remaining", working_time="Working time: 35 h a week", mentions=( "Keep this payslip without limit of time · HQF Development · " "42 lot les Genêts, 13480 Calas, France · SIRET 752 492 777 00012 · APE 6202A" ), ) # The payslip in French. FRENCH = Words( payslip="Bulletin de paie", month="juillet 2026", heading="BULLETIN DE PAIE", period_label="Période", period="1er – 31 juillet 2026", paid_label="Payé le", pay_date="31 juillet 2026", employee="SALARIÉE", role="Ingénieure logiciel confirmée — niveau 3.2", staff_label="Matricule", joined_label="Entrée le", joined_date="4 septembre 2023", net_paid="NET À PAYER", transferred="Virement sur le compte enregistré", hour="h", day="j", earnings_heading="Éléments de paie", quantity="Nombre", unit_rate="Taux unitaire", earnings_amount="Montant", earnings=( "Salaire de base mensuel", "Heures supplémentaires, 8 premières (125 %)", "Astreinte de week-end", "Prime d'ancienneté", ), gross_pay="SALAIRE BRUT", employee_share="Part salariale", employer_share="Part patronale", contribution="Cotisation", base="Base", rate="Taux", amount="Montant", lines=( "SANTÉ, MATERNITÉ, INVALIDITÉ, DÉCÈS", "Assurance maladie et maternité", "Complémentaire santé", "Indemnités journalières", "RETRAITE", "Assurance vieillesse plafonnée", "Assurance vieillesse déplafonnée", "Retraite complémentaire, tranche 1", "Retraite complémentaire, tranche 2", "Contribution d'équilibre, tranche 1", "Contribution d'équilibre, tranche 2", "FAMILLE ET CHÔMAGE", "Allocations familiales", "Assurance chômage", "Garantie des salaires", "AUTRES COTISATIONS PATRONALES", "Accidents du travail", "Contribution solidarité autonomie", "Taxe d'apprentissage", "Formation professionnelle", "CSG ET CRDS", "CSG déductible", "CSG et CRDS non déductibles", ), total_contributions="TOTAL DES COTISATIONS", net_before_tax="NET À PAYER AVANT IMPÔT", total_cost="COÛT TOTAL DU MOIS POUR L'EMPLOYEUR", summary="Récapitulatif", this_month="Ce mois", year_to_date="Cumul annuel", summary_lines=( "Salaire brut", "Cotisations salariales", "Cotisations patronales", "Net imposable", "Prélèvement à la source, 11.20 %", ), net_paid_row="NET À PAYER", leave="CONGÉS PAYÉS", leave_earned="Acquis cette année", leave_taken="pris", leave_remaining="solde", working_time="Temps de travail : 35 h par semaine", mentions=( "Bulletin à conserver sans limitation de durée · HQF Development · " "42 lot les Genêts, 13480 Calas, France · SIRET 752 492 777 00012 · APE 6202A" ), ) # Every language the example is written in. A language is added by writing its own set # of words and naming it here. WORDS = {_language.ENGLISH: ENGLISH, _language.FRENCH: FRENCH} def round2(value: float) -> float: """A value rounded to the hundredth, the way every figure on a payslip is carried. Each line is rounded before it is added, so the totals are the sum of what is printed. """ hundredths = value * 100.0 return math.floor(hundredths + 0.5) / 100.0 def amount(value: float) -> str: """An amount, as a payslip writes it: "4 647.59".""" units, hundredths = f"{value:.2f}".split(".") grouped = "" for index, digit in enumerate(units): if index > 0 and (len(units) - index) % 3 == 0: grouped += " " grouped += digit return f"{grouped}.{hundredths}" def percent(rate: float) -> str: """A rate, as a payslip writes it: "6.90 %". A rate of nothing is a dash, so that a column of rates reads as a column. """ if rate == 0.0: return "—" return f"{rate:.2f} %" class Payroll: """What the month comes to: the gross pay, the two sides of the contributions, and the surcharge that taxable pay takes back. """ def __init__(self) -> None: """Adds the earnings up, then charges every contribution against them.""" self.gross = sum( round2(earning.quantity * earning.unit_rate) for earning in EARNINGS ) self.employee = 0.0 self.employer = 0.0 self.non_deductible = 0.0 for line in LINES: if not isinstance(line, Charge): continue base = self.base(line.base) share = round2(base * line.deducted / 100.0) self.employee += share self.employer += round2(base * line.charged / 100.0) if line.non_deductible: self.non_deductible += share def base(self, base: str) -> float: """The figure a contribution's rates are applied to.""" if base == CAPPED: return CEILING if base == UPPER_BAND: return self.gross - CEILING if base == SURCHARGE: return round2(self.gross * SURCHARGE_SHARE) return self.gross def net_before_tax(self) -> float: """Gross pay less everything the employee contributes.""" return round2(self.gross - self.employee) def taxable(self) -> float: """What income tax is charged on: net pay before tax, plus the share of the social surcharges that tax does not let through. """ return round2(self.net_before_tax() + self.non_deductible) def tax(self) -> float: """The tax the employer withholds and pays over.""" return round2(self.taxable() * TAX_RATE / 100.0) def net_paid(self) -> float: """What lands in the employee's account.""" return round2(self.net_before_tax() - self.tax()) def text( content: hqf_pdf.Content, font: hqf_pdf.FontHandle, size: float, x: float, y: float, color: hqf_pdf.Rgb, s: str, ) -> None: """Draws a line of text, left-aligned, in a colour of its own.""" content.set_fill(color) content.draw_text(font, size, x, y, s) def text_right( content: hqf_pdf.Content, font: hqf_pdf.FontHandle, size: float, right: float, y: float, color: hqf_pdf.Rgb, s: str, ) -> None: """Draws a line of text whose right edge sits at ``right``.""" text(content, font, size, right - font.measure(s, size), y, color, s) def rule(content: hqf_pdf.Content, y: float, width: float, color: hqf_pdf.Rgb) -> None: """A horizontal rule from ``LEFT`` to ``RIGHT`` at height ``y``.""" content.set_stroke(color) content.set_line_width(width) content.move_to(LEFT, y) content.line_to(RIGHT, y) content.stroke() def pad() -> hqf_pdf.Padding: """The padding every cell of every table on this page is set in.""" return hqf_pdf.Padding.symmetric(4.0, 1.5) def figure(font: hqf_pdf.FontHandle, size: float, value: str) -> hqf_pdf.Cell: """A cell holding a figure: small, right-aligned, centred in its row.""" return hqf_pdf.Cell( font, size, value, padding=pad(), align=hqf_pdf.Align.Right, valign=hqf_pdf.VAlign.Middle, ) def heading( font: hqf_pdf.FontHandle, label: str, align: hqf_pdf.Align = hqf_pdf.Align.Left, span: int = 1, ) -> hqf_pdf.Cell: """A heading cell: white on the accent, centred in its row.""" return hqf_pdf.Cell( font, 7.0, label, padding=pad(), fill=ACCENT, color=hqf_pdf.Rgb.gray(1.0), align=align, span=span, valign=hqf_pdf.VAlign.Middle, ) def earnings_table( font: hqf_pdf.FontHandle, words: Words, payroll: Payroll ) -> hqf_pdf.Table: """The earnings table: what the month pays, line by line, and the gross it comes to. """ # The description takes whatever the three figure columns leave it. columns = hqf_pdf.Columns( [ hqf_pdf.ColumnWidth.fraction(1.0), hqf_pdf.ColumnWidth.points(70.0), hqf_pdf.ColumnWidth.points(70.0), hqf_pdf.ColumnWidth.points(80.0), ], TABLE_WIDTH, ) table = hqf_pdf.Table(columns) table.header(1) table.rule(hqf_pdf.Rule.frame(), hqf_pdf.Stroke(0.8, ACCENT)) table.rule( hqf_pdf.Rule.horizontal_other(), hqf_pdf.Stroke(0.25, hqf_pdf.Rgb.gray(0.82)) ) table.rule(hqf_pdf.Rule.horizontal(1), hqf_pdf.Stroke(0.8, ACCENT)) table.rule(hqf_pdf.Rule.horizontal_from_end(1), hqf_pdf.Stroke(0.8, ACCENT)) table.push( hqf_pdf.Row( [ heading(font, words.earnings_heading), heading(font, words.quantity, hqf_pdf.Align.Right), heading(font, words.unit_rate, hqf_pdf.Align.Right), heading(font, words.earnings_amount, hqf_pdf.Align.Right), ], min_height=15.0, ) ) for index, (earning, label) in enumerate(zip(EARNINGS, words.earnings)): unit = words.unit(earning.unit) if unit: quantity = f"{earning.quantity:.2f} {unit}" else: quantity = f"{earning.quantity:.2f}" table.push( hqf_pdf.Row( [ hqf_pdf.Cell( font, 7.5, label, padding=pad(), valign=hqf_pdf.VAlign.Middle, ), figure(font, 7.5, quantity), figure(font, 7.5, f"{earning.unit_rate:.4f}"), figure( font, 7.5, amount(round2(earning.quantity * earning.unit_rate)) ), ], min_height=13.0, fill=hqf_pdf.Rgb.gray(0.96) if index % 2 else None, ) ) table.push( hqf_pdf.Row( [ hqf_pdf.Cell( font, 8.0, words.gross_pay, span=3, align=hqf_pdf.Align.Right, padding=pad(), valign=hqf_pdf.VAlign.Middle, ), figure(font, 8.0, amount(payroll.gross)), ], min_height=15.0, ) ) return table def contributions_table( font: hqf_pdf.FontHandle, words: Words, payroll: Payroll ) -> hqf_pdf.Table: """The contributions table: two tiers of headings, a heading row for each family of contributions, one row per contribution, and the three totals. """ # Four figure columns for the two shares, one for the base, and whatever is left # over for the wording. columns = hqf_pdf.Columns( [ hqf_pdf.ColumnWidth.fraction(1.0), hqf_pdf.ColumnWidth.points(62.0), hqf_pdf.ColumnWidth.points(42.0), hqf_pdf.ColumnWidth.points(62.0), hqf_pdf.ColumnWidth.points(42.0), hqf_pdf.ColumnWidth.points(62.0), ], TABLE_WIDTH, ) table = hqf_pdf.Table(columns) # Both tiers of the heading repeat if the table ever continues on a second page. table.header(2) table.rule(hqf_pdf.Rule.frame(), hqf_pdf.Stroke(0.8, ACCENT)) table.rule( hqf_pdf.Rule.horizontal_other(), hqf_pdf.Stroke(0.25, hqf_pdf.Rgb.gray(0.85)) ) table.rule(hqf_pdf.Rule.horizontal(1), hqf_pdf.Stroke(0.4, hqf_pdf.Rgb.gray(1.0))) table.rule(hqf_pdf.Rule.horizontal(2), hqf_pdf.Stroke(0.8, ACCENT)) table.rule(hqf_pdf.Rule.horizontal_from_end(3), hqf_pdf.Stroke(0.8, ACCENT)) table.rule(hqf_pdf.Rule.vertical(2), hqf_pdf.Stroke(0.4, hqf_pdf.Rgb.gray(0.72))) table.rule(hqf_pdf.Rule.vertical(4), hqf_pdf.Stroke(0.4, hqf_pdf.Rgb.gray(0.72))) table.push( hqf_pdf.Row( [ heading(font, "", span=2), heading(font, words.employee_share, hqf_pdf.Align.Center, span=2), heading(font, words.employer_share, hqf_pdf.Align.Center, span=2), ], min_height=13.0, ) ) table.push( hqf_pdf.Row( [ heading(font, words.contribution), heading(font, words.base, hqf_pdf.Align.Right), heading(font, words.rate, hqf_pdf.Align.Right), heading(font, words.amount, hqf_pdf.Align.Right), heading(font, words.rate, hqf_pdf.Align.Right), heading(font, words.amount, hqf_pdf.Align.Right), ], min_height=13.0, ) ) for line, label in zip(LINES, words.lines): if isinstance(line, Section): table.push( hqf_pdf.Row( [ hqf_pdf.Cell( font, 7.0, label, span=6, padding=pad(), color=ACCENT, valign=hqf_pdf.VAlign.Middle, ) ], fill=hqf_pdf.Rgb.gray(0.91), min_height=12.0, ) ) continue base = payroll.base(line.base) def share(rate: float, base: float = base) -> str: return "" if rate == 0.0 else amount(round2(base * rate / 100.0)) table.push( hqf_pdf.Row( [ hqf_pdf.Cell( font, 7.0, label, padding=pad(), valign=hqf_pdf.VAlign.Middle, ), figure(font, 7.0, amount(base)), figure(font, 7.0, percent(line.deducted)), figure(font, 7.0, share(line.deducted)), figure(font, 7.0, percent(line.charged)), figure(font, 7.0, share(line.charged)), ], min_height=11.5, ) ) contribution_totals(table, font, words, payroll) return table def contribution_totals( table: hqf_pdf.Table, font: hqf_pdf.FontHandle, words: Words, payroll: Payroll ) -> None: """Closes the contributions table off: the two columns of shares added up under their own heads, then the net pay and the cost of the month. """ table.push( hqf_pdf.Row( [ hqf_pdf.Cell( font, 8.0, words.total_contributions, span=3, align=hqf_pdf.Align.Right, padding=pad(), valign=hqf_pdf.VAlign.Middle, ), figure(font, 8.0, amount(payroll.employee)), hqf_pdf.Cell(font, 8.0, "", padding=pad()), figure(font, 8.0, amount(payroll.employer)), ], min_height=15.0, ) ) # The last two lines are boxed off the grid so that they read as totals rather than # as more lines of it: the label carries the box's left edge and the figure its # right, so the two trace one box between them. stroke = hqf_pdf.Stroke(0.8, ACCENT) box_margin = hqf_pdf.Margin.symmetric(0.0, 2.0) label_border = hqf_pdf.Border(top=stroke, bottom=stroke, left=stroke) value_border = hqf_pdf.Border(top=stroke, bottom=stroke, right=stroke) table.push( hqf_pdf.Row( [ hqf_pdf.Cell( font, 8.0, words.net_before_tax, span=3, align=hqf_pdf.Align.Right, padding=pad(), margin=box_margin, border=label_border, valign=hqf_pdf.VAlign.Middle, ), hqf_pdf.Cell( font, 8.0, amount(payroll.net_before_tax()), align=hqf_pdf.Align.Right, padding=pad(), margin=box_margin, border=value_border, valign=hqf_pdf.VAlign.Middle, ), hqf_pdf.Cell(font, 8.0, "", span=2, padding=pad()), ], min_height=15.0, ) ) table.push( hqf_pdf.Row( [ hqf_pdf.Cell( font, 7.5, words.total_cost, span=5, align=hqf_pdf.Align.Right, padding=pad(), margin=box_margin, border=label_border, valign=hqf_pdf.VAlign.Middle, ), hqf_pdf.Cell( font, 7.5, amount(round2(payroll.gross + payroll.employer)), align=hqf_pdf.Align.Right, padding=pad(), margin=box_margin, border=value_border, valign=hqf_pdf.VAlign.Middle, ), ], min_height=14.0, ) ) def cumulative_table( font: hqf_pdf.FontHandle, words: Words, payroll: Payroll ) -> hqf_pdf.Table: """The cumulative table: what the month came to beside what the year has come to, the income tax withheld, and the net that is paid over. """ columns = hqf_pdf.Columns( [ hqf_pdf.ColumnWidth.fraction(1.0), hqf_pdf.ColumnWidth.points(96.0), hqf_pdf.ColumnWidth.points(96.0), ], TABLE_WIDTH, ) table = hqf_pdf.Table(columns) table.header(1) table.rule(hqf_pdf.Rule.frame(), hqf_pdf.Stroke(0.8, ACCENT)) table.rule( hqf_pdf.Rule.horizontal_other(), hqf_pdf.Stroke(0.25, hqf_pdf.Rgb.gray(0.82)) ) table.rule(hqf_pdf.Rule.horizontal(1), hqf_pdf.Stroke(0.8, ACCENT)) table.rule(hqf_pdf.Rule.horizontal_from_end(1), hqf_pdf.Stroke(0.8, ACCENT)) table.push( hqf_pdf.Row( [ heading(font, words.summary), heading(font, words.this_month, hqf_pdf.Align.Right), heading(font, words.year_to_date, hqf_pdf.Align.Right), ], min_height=15.0, ) ) values = [ payroll.gross, payroll.employee, payroll.employer, payroll.taxable(), payroll.tax(), ] for index, (label, value) in enumerate(zip(words.summary_lines, values)): table.push( hqf_pdf.Row( [ hqf_pdf.Cell( font, 7.5, label, padding=pad(), valign=hqf_pdf.VAlign.Middle ), figure(font, 7.5, amount(value)), figure(font, 7.5, amount(round2(value * MONTHS))), ], min_height=13.0, fill=hqf_pdf.Rgb.gray(0.96) if index % 2 else None, ) ) net_paid = payroll.net_paid() table.push( hqf_pdf.Row( [ hqf_pdf.Cell( font, 8.5, words.net_paid_row, padding=pad(), color=ACCENT, valign=hqf_pdf.VAlign.Middle, ), hqf_pdf.Cell( font, 8.5, amount(net_paid), padding=pad(), align=hqf_pdf.Align.Right, valign=hqf_pdf.VAlign.Middle, color=ACCENT, ), figure(font, 8.5, amount(round2(net_paid * MONTHS))), ], min_height=17.0, ) ) return table def letterhead( content: hqf_pdf.Content, font: hqf_pdf.FontHandle, logo: hqf_pdf.ImageHandle, words: Words, ) -> None: """Draws the letterhead: the mark, the employer, the word the page is, and the month it covers, closed off by a rule. """ logo_w, logo_h = logo.fit_within(62.25, 62.25) content.draw_image(logo, LEFT, 826.5 - logo_h, logo_w, logo_h) for y, line in ( (782.0, "42 lot les Genêts, 13480 Calas, France"), (771.0, "SIRET 752 492 777 00012 · APE 6202A · www.hqf.fr"), ): text(content, font, 8.5, LEFT, y, MUTED, line) text_right(content, font, 26.0, RIGHT, 802.0, ACCENT, words.heading) text_right( content, font, 9.0, RIGHT, 783.0, INK, f"{words.period_label} {words.period}" ) text_right( content, font, 9.0, RIGHT, 771.0, MUTED, f"{words.paid_label} {words.pay_date}" ) rule(content, 758.0, 1.2, ACCENT) def employee( content: hqf_pdf.Content, font: hqf_pdf.FontHandle, words: Words, payroll: Payroll ) -> None: """Draws who is being paid and — set apart on the right — what they are paid.""" text(content, font, 7.5, LEFT, 742.0, MUTED, words.employee) text(content, font, 11.0, LEFT, 728.0, INK, EMPLOYEE_NAME) text(content, font, 8.0, LEFT, 715.0, MUTED, words.role) text( content, font, 8.0, LEFT, 704.0, MUTED, f"{words.staff_label} {EMPLOYEE_ID} · {words.joined_label} {words.joined_date}", ) text_right(content, font, 7.5, RIGHT, 742.0, MUTED, words.net_paid) text_right( content, font, 18.0, RIGHT, 724.0, ACCENT, f"{amount(payroll.net_paid())} EUR" ) text_right(content, font, 8.0, RIGHT, 708.0, MUTED, words.transferred) def footer( content: hqf_pdf.Content, font: hqf_pdf.FontHandle, words: Words, top: float ) -> None: """Draws the leave the employee stands at, and the small print the foot of the page carries. """ text(content, font, 7.5, LEFT, top, ACCENT, words.leave) day = words.day leave = ( f"{words.leave_earned} {LEAVE_EARNED:.2f} {day} · " f"{words.leave_taken} {LEAVE_TAKEN:.2f} {day} · " f"{words.leave_remaining} {LEAVE_EARNED - LEAVE_TAKEN:.2f} {day}" ) text(content, font, 8.0, LEFT, top - 13.0, INK, leave) text_right(content, font, 8.0, RIGHT, top - 13.0, MUTED, words.working_time) rule(content, 74.0, 0.5, hqf_pdf.Rgb.gray(0.8)) text( content, font, 6.5, LEFT + (TABLE_WIDTH - font.measure(words.mentions, 6.5)) / 2.0, 62.0, MUTED, words.mentions, ) def main() -> None: language = _language.from_environment() words = _language.words_of(WORDS, language) # A named file is written as named; the default one carries the language, so the two # languages do not overwrite each other in `tmp/`. out = _out.output_path(Path(_language.file_name("payslip.pdf", language)).stem) document = hqf_pdf.Document() document.set_license(_licence.licensed()) document.set_info("Title", f"{words.payslip} — {words.month}") font = document.add_font(hqf_pdf.Font.from_path(_out.font_path())) logo = document.add_image(hqf_pdf.Image.from_path(LOGO)) payroll = Payroll() content = hqf_pdf.Content() letterhead(content, font, logo, words) employee(content, font, words, payroll) # The three tables are stacked down the page, each one starting a fixed gap below # where the one above it stopped. top = 686.0 for table in ( earnings_table(font, words, payroll), contributions_table(font, words, payroll), cumulative_table(font, words, payroll), ): placed = table.fit(LEFT, top, top - 80.0, 0) placed.draw(content) top -= placed.height + 18.0 footer(content, font, words, top - 4.0) page = hqf_pdf.Page(PAGE_WIDTH, PAGE_HEIGHT) page.set_content(content) document.add_page(page) written = document.write(out) print( f"wrote {out}: {written} bytes, {amount(payroll.gross)} gross, " f"{amount(payroll.net_paid())} net" ) if __name__ == "__main__": main()