Python's calendar.calendar in TypeScript

✓ Verified: Python 3.12

How to use

Install via yarn add locutus and import: import { calendar } from 'locutus/python/calendar/calendar'.

Or with CommonJS: const { calendar } = require('locutus/python/calendar/calendar')

Use a bundler that supports tree-shaking so you only ship the functions you actually use. Vite, webpack, Rollup, and Parcel all handle this. For server-side use this is less of a concern.

Examples

These examples are extracted from test cases that automatically verify our functions against their native counterparts.

#	code	expected result
1	`calendar(2024)`	' 2024\n\n January February March\nMo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su\n 1 2 3 4 5 6 7 1 2 3 4 1 2 3\n 8 9 10 11 12 13 14 5 6 7 8 9 10 11 4 5 6 7 8 9 10\n15 16 17 18 19 20 21 12 13 14 15 16 17 18 11 12 13 14 15 16 17\n22 23 24 25 26 27 28 19 20 21 22 23 24 25 18 19 20 21 22 23 24\n29 30 31 26 27 28 29 25 26 27 28 29 30 31\n\n April May June\nMo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su\n 1 2 3 4 5 6 7 1 2 3 4 5 1 2\n 8 9 10 11 12 13 14 6 7 8 9 10 11 12 3 4 5 6 7 8 9\n15 16 17 18 19 20 21 13 14 15 16 17 18 19 10 11 12 13 14 15 16\n22 23 24 25 26 27 28 20 21 22 23 24 25 26 17 18 19 20 21 22 23\n29 30 27 28 29 30 31 24 25 26 27 28 29 30\n\n July August September\nMo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su\n 1 2 3 4 5 6 7 1 2 3 4 1\n 8 9 10 11 12 13 14 5 6 7 8 9 10 11 2 3 4 5 6 7 8\n15 16 17 18 19 20 21 12 13 14 15 16 17 18 9 10 11 12 13 14 15\n22 23 24 25 26 27 28 19 20 21 22 23 24 25 16 17 18 19 20 21 22\n29 30 31 26 27 28 29 30 31 23 24 25 26 27 28 29\n 30\n\n October November December\nMo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su\n 1 2 3 4 5 6 1 2 3 1\n 7 8 9 10 11 12 13 4 5 6 7 8 9 10 2 3 4 5 6 7 8\n14 15 16 17 18 19 20 11 12 13 14 15 16 17 9 10 11 12 13 14 15\n21 22 23 24 25 26 27 18 19 20 21 22 23 24 16 17 18 19 20 21 22\n28 29 30 31 25 26 27 28 29 30 23 24 25 26 27 28 29\n 30 31\n'

Dependencies

This function uses the following Locutus functions:

_calendar (python/_helpers)

Here's what our current TypeScript equivalent to Python's calendar.calendar looks like.

import {
  formatYear,
  normalizeCalendarYear,
  normalizeColumnSpacing,
  normalizeLineSpacing,
  normalizeMonthsPerRow,
  normalizeMonthWidth,
} from '../_helpers/_calendar.ts'

export function calendar(theyear: unknown, w = 2, l = 1, c = 6, m = 3): string {
  //      discuss at: https://locutus.io/python/calendar/calendar/
  // parity verified: Python 3.12
  //     original by: Kevin van Zonneveld (https://kvz.io)
  //       example 1: calendar(2024)
  //       returns 1: '                                  2024\n\n      January                   February                   March\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n 1  2  3  4  5  6  7                1  2  3  4                   1  2  3\n 8  9 10 11 12 13 14       5  6  7  8  9 10 11       4  5  6  7  8  9 10\n15 16 17 18 19 20 21      12 13 14 15 16 17 18      11 12 13 14 15 16 17\n22 23 24 25 26 27 28      19 20 21 22 23 24 25      18 19 20 21 22 23 24\n29 30 31                  26 27 28 29               25 26 27 28 29 30 31\n\n       April                      May                       June\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n 1  2  3  4  5  6  7             1  2  3  4  5                      1  2\n 8  9 10 11 12 13 14       6  7  8  9 10 11 12       3  4  5  6  7  8  9\n15 16 17 18 19 20 21      13 14 15 16 17 18 19      10 11 12 13 14 15 16\n22 23 24 25 26 27 28      20 21 22 23 24 25 26      17 18 19 20 21 22 23\n29 30                     27 28 29 30 31            24 25 26 27 28 29 30\n\n        July                     August                  September\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n 1  2  3  4  5  6  7                1  2  3  4                         1\n 8  9 10 11 12 13 14       5  6  7  8  9 10 11       2  3  4  5  6  7  8\n15 16 17 18 19 20 21      12 13 14 15 16 17 18       9 10 11 12 13 14 15\n22 23 24 25 26 27 28      19 20 21 22 23 24 25      16 17 18 19 20 21 22\n29 30 31                  26 27 28 29 30 31         23 24 25 26 27 28 29\n                                                    30\n\n      October                   November                  December\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n    1  2  3  4  5  6                   1  2  3                         1\n 7  8  9 10 11 12 13       4  5  6  7  8  9 10       2  3  4  5  6  7  8\n14 15 16 17 18 19 20      11 12 13 14 15 16 17       9 10 11 12 13 14 15\n21 22 23 24 25 26 27      18 19 20 21 22 23 24      16 17 18 19 20 21 22\n28 29 30 31               25 26 27 28 29 30         23 24 25 26 27 28 29\n                                                    30 31\n'

  if (arguments.length === 0) {
    throw new TypeError("TextCalendar.formatyear() missing 1 required positional argument: 'theyear'")
  }

  return formatYear(
    normalizeCalendarYear(theyear, 'calendar'),
    normalizeMonthWidth(w, 'calendar'),
    normalizeLineSpacing(l, 'calendar'),
    normalizeColumnSpacing(c, 'calendar'),
    normalizeMonthsPerRow(m, 'calendar'),
  )
}

import {
  formatYear,
  normalizeCalendarYear,
  normalizeColumnSpacing,
  normalizeLineSpacing,
  normalizeMonthsPerRow,
  normalizeMonthWidth,
} from '../_helpers/_calendar.ts'

export function calendar(theyear, w = 2, l = 1, c = 6, m = 3) {
  //      discuss at: https://locutus.io/python/calendar/calendar/
  // parity verified: Python 3.12
  //     original by: Kevin van Zonneveld (https://kvz.io)
  //       example 1: calendar(2024)
  //       returns 1: '                                  2024\n\n      January                   February                   March\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n 1  2  3  4  5  6  7                1  2  3  4                   1  2  3\n 8  9 10 11 12 13 14       5  6  7  8  9 10 11       4  5  6  7  8  9 10\n15 16 17 18 19 20 21      12 13 14 15 16 17 18      11 12 13 14 15 16 17\n22 23 24 25 26 27 28      19 20 21 22 23 24 25      18 19 20 21 22 23 24\n29 30 31                  26 27 28 29               25 26 27 28 29 30 31\n\n       April                      May                       June\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n 1  2  3  4  5  6  7             1  2  3  4  5                      1  2\n 8  9 10 11 12 13 14       6  7  8  9 10 11 12       3  4  5  6  7  8  9\n15 16 17 18 19 20 21      13 14 15 16 17 18 19      10 11 12 13 14 15 16\n22 23 24 25 26 27 28      20 21 22 23 24 25 26      17 18 19 20 21 22 23\n29 30                     27 28 29 30 31            24 25 26 27 28 29 30\n\n        July                     August                  September\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n 1  2  3  4  5  6  7                1  2  3  4                         1\n 8  9 10 11 12 13 14       5  6  7  8  9 10 11       2  3  4  5  6  7  8\n15 16 17 18 19 20 21      12 13 14 15 16 17 18       9 10 11 12 13 14 15\n22 23 24 25 26 27 28      19 20 21 22 23 24 25      16 17 18 19 20 21 22\n29 30 31                  26 27 28 29 30 31         23 24 25 26 27 28 29\n                                                    30\n\n      October                   November                  December\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n    1  2  3  4  5  6                   1  2  3                         1\n 7  8  9 10 11 12 13       4  5  6  7  8  9 10       2  3  4  5  6  7  8\n14 15 16 17 18 19 20      11 12 13 14 15 16 17       9 10 11 12 13 14 15\n21 22 23 24 25 26 27      18 19 20 21 22 23 24      16 17 18 19 20 21 22\n28 29 30 31               25 26 27 28 29 30         23 24 25 26 27 28 29\n                                                    30 31\n'

  if (arguments.length === 0) {
    throw new TypeError("TextCalendar.formatyear() missing 1 required positional argument: 'theyear'")
  }

  return formatYear(
    normalizeCalendarYear(theyear, 'calendar'),
    normalizeMonthWidth(w, 'calendar'),
    normalizeLineSpacing(l, 'calendar'),
    normalizeColumnSpacing(c, 'calendar'),
    normalizeMonthsPerRow(m, 'calendar'),
  )
}

// python/_helpers/_calendar (Locutus helper dependency)
const DAY_ABBR = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'] as const

const MONTH_NAMES = [
  '',
  'January',
  'February',
  'March',
  'April',
  'May',
  'June',
  'July',
  'August',
  'September',
  'October',
  'November',
  'December',
] as const

function toCalendarInteger(value: unknown, functionName: string): number {
  if (typeof value === 'boolean') {
    return value ? 1 : 0
  }

  if (typeof value === 'bigint') {
    const numericValue = Number(value)
    if (!Number.isSafeInteger(numericValue)) {
      throw new RangeError(`${functionName}() integer arguments must fit within JS safe integer precision`)
    }

    return numericValue
  }

  if (typeof value === 'number' && Number.isFinite(value) && Number.isSafeInteger(value)) {
    return value
  }

  throw new TypeError(`${functionName}() requires integer arguments`)
}

function normalizeCalendarYear(value: unknown, functionName: string): number {
  return toCalendarInteger(value, functionName)
}

function normalizeMonthWidth(value: unknown, functionName: string): number {
  return Math.max(toCalendarInteger(value, functionName), 2)
}

function normalizeLineSpacing(value: unknown, functionName: string): number {
  return Math.max(toCalendarInteger(value, functionName), 1)
}

function normalizeColumnSpacing(value: unknown, functionName: string): number {
  return Math.max(toCalendarInteger(value, functionName), 2)
}

function normalizeMonthsPerRow(value: unknown, functionName: string): number {
  return Math.max(toCalendarInteger(value, functionName), 1)
}

function isLeapYear(year: number): boolean {
  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)
}

function daysInMonth(year: number, month: number): number {
  if (month === 2) {
    return isLeapYear(year) ? 29 : 28
  }

  return [4, 6, 9, 11].includes(month) ? 30 : 31
}

function pythonWeekday(year: number, month: number, day: number): number {
  const ordinal = daysBeforeYear(year) + daysBeforeMonth(year, month) + day
  return positiveModulo(ordinal - 1, 7)
}

function buildWeekHeader(width: number): string {
  return DAY_ABBR.map((name) => {
    const truncated = name.slice(0, width)
    return width > truncated.length ? centerText(truncated, width) : truncated
  }).join(' ')
}

function buildMonthCalendar(year: number, month: number): number[][] {
  const totalDays = daysInMonth(year, month)
  const firstWeekday = pythonWeekday(year, month, 1)
  const weeks: number[][] = []

  let currentWeek = new Array<number>(7).fill(0)
  let weekdayIndex = firstWeekday

  for (let day = 1; day <= totalDays; day += 1) {
    currentWeek[weekdayIndex] = day
    weekdayIndex += 1

    if (weekdayIndex === 7) {
      weeks.push(currentWeek)
      currentWeek = new Array<number>(7).fill(0)
      weekdayIndex = 0
    }
  }

  if (weekdayIndex !== 0) {
    weeks.push(currentWeek)
  }

  return weeks
}

function formatWeek(theweek: unknown, width: unknown): string {
  if (!Array.isArray(theweek)) {
    throw new TypeError("'int' object is not iterable")
  }

  const rawWidth = toCalendarInteger(width, 'week')
  return theweek
    .map((entry) => {
      if (!Array.isArray(entry)) {
        throw new TypeError("'int' object is not iterable")
      }

      const day = entry[0]
      if (typeof day !== 'number' || !Number.isInteger(day)) {
        throw new TypeError("'int' object is not iterable")
      }

      if (day === 0) {
        return centerText('', rawWidth)
      }

      return centerText(String(day).padStart(2, ' '), rawWidth)
    })
    .join(' ')
}

function formatString(items: unknown, cols = 20, spacing = 6): string {
  if (!isIterable(items)) {
    throw new TypeError("'object' object is not iterable")
  }

  const values = [...items]
  return values.map((value) => centerMethodString(value, cols)).join(' '.repeat(spacing))
}

function formatYear(
  year: number,
  width: number,
  lineSpacing: number,
  columnSpacing: number,
  monthsPerRow: number,
): string {
  const monthWidth = 7 * (width + 1) - 1
  const yearWidth = monthWidth * monthsPerRow + columnSpacing * (monthsPerRow - 1)
  const lines: string[] = [centerText(String(year), yearWidth).replace(/\s+$/, ''), '\n'.repeat(lineSpacing)]
  const header = buildWeekHeader(width)
  const monthRows = Array.from({ length: Math.ceil(12 / monthsPerRow) }, (_, rowIndex) =>
    Array.from({ length: monthsPerRow }, (_, columnIndex) => rowIndex * monthsPerRow + columnIndex + 1).filter(
      (month) => month <= 12,
    ),
  )

  for (const months of monthRows) {
    lines.push('\n'.repeat(lineSpacing))
    lines.push(
      formatString(
        months.map((month) => centerText(MONTH_NAMES[month] ?? '', monthWidth)),
        monthWidth,
        columnSpacing,
      ).replace(/\s+$/, ''),
    )
    lines.push('\n'.repeat(lineSpacing))
    lines.push(
      formatString(
        months.map(() => header),
        monthWidth,
        columnSpacing,
      ).replace(/\s+$/, ''),
    )
    lines.push('\n'.repeat(lineSpacing))

    const weeks = months.map((month) => buildMonthCalendar(year, month))
    const height = Math.max(...weeks.map((calendarRows) => calendarRows.length))

    for (let weekIndex = 0; weekIndex < height; weekIndex += 1) {
      lines.push(
        formatString(
          weeks.map((calendarRows) =>
            weekIndex >= calendarRows.length
              ? ''
              : formatWeek(
                  (calendarRows[weekIndex] ?? []).map((day, weekday) => [day, weekday]),
                  width,
                ),
          ),
          monthWidth,
          columnSpacing,
        ).replace(/\s+$/, ''),
      )
      lines.push('\n'.repeat(lineSpacing))
    }
  }

  return lines.join('')
}

function daysBeforeYear(year: number): number {
  const adjusted = year - 1
  return adjusted * 365 + Math.floor(adjusted / 4) - Math.floor(adjusted / 100) + Math.floor(adjusted / 400)
}

function daysBeforeMonth(year: number, month: number): number {
  const offsets = isLeapYear(year)
    ? [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]
    : [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]
  return offsets[month - 1] ?? 0
}

function centerText(value: string, width: number): string {
  if (width <= value.length) {
    return value
  }

  const leftPadding = Math.floor((width - value.length) / 2)
  const rightPadding = width - value.length - leftPadding
  return `${' '.repeat(leftPadding)}${value}${' '.repeat(rightPadding)}`
}

function positiveModulo(value: number, modulus: number): number {
  return ((value % modulus) + modulus) % modulus
}

function isIterable(value: unknown): value is Iterable<unknown> {
  return (
    value !== null &&
    value !== undefined &&
    typeof (value as { [Symbol.iterator]?: unknown })[Symbol.iterator] === 'function'
  )
}

function centerMethodString(value: unknown, width: number): string {
  if (typeof value !== 'string') {
    throw new AttributeError(`${value === null ? 'NoneType' : typeof value} object has no attribute 'center'`)
  }

  return centerText(value, width)
}

class AttributeError extends Error {
  constructor(message: string) {
    super(message)
    this.name = 'AttributeError'
  }
}

// python/calendar/calendar (target function module)
function calendar(theyear: unknown, w = 2, l = 1, c = 6, m = 3): string {
  //      discuss at: https://locutus.io/python/calendar/calendar/
  // parity verified: Python 3.12
  //     original by: Kevin van Zonneveld (https://kvz.io)
  //       example 1: calendar(2024)
  //       returns 1: '                                  2024\n\n      January                   February                   March\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n 1  2  3  4  5  6  7                1  2  3  4                   1  2  3\n 8  9 10 11 12 13 14       5  6  7  8  9 10 11       4  5  6  7  8  9 10\n15 16 17 18 19 20 21      12 13 14 15 16 17 18      11 12 13 14 15 16 17\n22 23 24 25 26 27 28      19 20 21 22 23 24 25      18 19 20 21 22 23 24\n29 30 31                  26 27 28 29               25 26 27 28 29 30 31\n\n       April                      May                       June\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n 1  2  3  4  5  6  7             1  2  3  4  5                      1  2\n 8  9 10 11 12 13 14       6  7  8  9 10 11 12       3  4  5  6  7  8  9\n15 16 17 18 19 20 21      13 14 15 16 17 18 19      10 11 12 13 14 15 16\n22 23 24 25 26 27 28      20 21 22 23 24 25 26      17 18 19 20 21 22 23\n29 30                     27 28 29 30 31            24 25 26 27 28 29 30\n\n        July                     August                  September\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n 1  2  3  4  5  6  7                1  2  3  4                         1\n 8  9 10 11 12 13 14       5  6  7  8  9 10 11       2  3  4  5  6  7  8\n15 16 17 18 19 20 21      12 13 14 15 16 17 18       9 10 11 12 13 14 15\n22 23 24 25 26 27 28      19 20 21 22 23 24 25      16 17 18 19 20 21 22\n29 30 31                  26 27 28 29 30 31         23 24 25 26 27 28 29\n                                                    30\n\n      October                   November                  December\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n    1  2  3  4  5  6                   1  2  3                         1\n 7  8  9 10 11 12 13       4  5  6  7  8  9 10       2  3  4  5  6  7  8\n14 15 16 17 18 19 20      11 12 13 14 15 16 17       9 10 11 12 13 14 15\n21 22 23 24 25 26 27      18 19 20 21 22 23 24      16 17 18 19 20 21 22\n28 29 30 31               25 26 27 28 29 30         23 24 25 26 27 28 29\n                                                    30 31\n'

  if (arguments.length === 0) {
    throw new TypeError("TextCalendar.formatyear() missing 1 required positional argument: 'theyear'")
  }

  return formatYear(
    normalizeCalendarYear(theyear, 'calendar'),
    normalizeMonthWidth(w, 'calendar'),
    normalizeLineSpacing(l, 'calendar'),
    normalizeColumnSpacing(c, 'calendar'),
    normalizeMonthsPerRow(m, 'calendar'),
  )
}

// python/_helpers/_calendar (Locutus helper dependency)
const DAY_ABBR = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']

const MONTH_NAMES = [
  '',
  'January',
  'February',
  'March',
  'April',
  'May',
  'June',
  'July',
  'August',
  'September',
  'October',
  'November',
  'December',
]

function toCalendarInteger(value, functionName) {
  if (typeof value === 'boolean') {
    return value ? 1 : 0
  }

  if (typeof value === 'bigint') {
    const numericValue = Number(value)
    if (!Number.isSafeInteger(numericValue)) {
      throw new RangeError(`${functionName}() integer arguments must fit within JS safe integer precision`)
    }

    return numericValue
  }

  if (typeof value === 'number' && Number.isFinite(value) && Number.isSafeInteger(value)) {
    return value
  }

  throw new TypeError(`${functionName}() requires integer arguments`)
}

function normalizeMonthWidth(value, functionName) {
  return Math.max(toCalendarInteger(value, functionName), 2)
}

function normalizeLineSpacing(value, functionName) {
  return Math.max(toCalendarInteger(value, functionName), 1)
}

function normalizeColumnSpacing(value, functionName) {
  return Math.max(toCalendarInteger(value, functionName), 2)
}

function normalizeMonthsPerRow(value, functionName) {
  return Math.max(toCalendarInteger(value, functionName), 1)
}

function isLeapYear(year) {
  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)
}

function daysInMonth(year, month) {
  if (month === 2) {
    return isLeapYear(year) ? 29 : 28
  }

  return [4, 6, 9, 11].includes(month) ? 30 : 31
}

function pythonWeekday(year, month, day) {
  const ordinal = daysBeforeYear(year) + daysBeforeMonth(year, month) + day
  return positiveModulo(ordinal - 1, 7)
}

function buildWeekHeader(width) {
  return DAY_ABBR.map((name) => {
    const truncated = name.slice(0, width)
    return width > truncated.length ? centerText(truncated, width) : truncated
  }).join(' ')
}

function buildMonthCalendar(year, month) {
  const totalDays = daysInMonth(year, month)
  const firstWeekday = pythonWeekday(year, month, 1)
  const weeks = []

  let currentWeek = new Array(7).fill(0)
  let weekdayIndex = firstWeekday

  for (let day = 1; day <= totalDays; day += 1) {
    currentWeek[weekdayIndex] = day
    weekdayIndex += 1

    if (weekdayIndex === 7) {
      weeks.push(currentWeek)
      currentWeek = new Array(7).fill(0)
      weekdayIndex = 0
    }
  }

  if (weekdayIndex !== 0) {
    weeks.push(currentWeek)
  }

  return weeks
}

function formatWeek(theweek, width) {
  if (!Array.isArray(theweek)) {
    throw new TypeError("'int' object is not iterable")
  }

  const rawWidth = toCalendarInteger(width, 'week')
  return theweek
    .map((entry) => {
      if (!Array.isArray(entry)) {
        throw new TypeError("'int' object is not iterable")
      }

      const day = entry[0]
      if (typeof day !== 'number' || !Number.isInteger(day)) {
        throw new TypeError("'int' object is not iterable")
      }

      if (day === 0) {
        return centerText('', rawWidth)
      }

      return centerText(String(day).padStart(2, ' '), rawWidth)
    })
    .join(' ')
}

function formatString(items, cols = 20, spacing = 6) {
  if (!isIterable(items)) {
    throw new TypeError("'object' object is not iterable")
  }

  const values = [...items]
  return values.map((value) => centerMethodString(value, cols)).join(' '.repeat(spacing))
}

function formatYear(year, width, lineSpacing, columnSpacing, monthsPerRow) {
  const monthWidth = 7 * (width + 1) - 1
  const yearWidth = monthWidth * monthsPerRow + columnSpacing * (monthsPerRow - 1)
  const lines = [centerText(String(year), yearWidth).replace(/\s+$/, ''), '\n'.repeat(lineSpacing)]
  const header = buildWeekHeader(width)
  const monthRows = Array.from({ length: Math.ceil(12 / monthsPerRow) }, (_, rowIndex) =>
    Array.from({ length: monthsPerRow }, (_, columnIndex) => rowIndex * monthsPerRow + columnIndex + 1).filter(
      (month) => month <= 12,
    ),
  )

  for (const months of monthRows) {
    lines.push('\n'.repeat(lineSpacing))
    lines.push(
      formatString(
        months.map((month) => centerText(MONTH_NAMES[month] ?? '', monthWidth)),
        monthWidth,
        columnSpacing,
      ).replace(/\s+$/, ''),
    )
    lines.push('\n'.repeat(lineSpacing))
    lines.push(
      formatString(
        months.map(() => header),
        monthWidth,
        columnSpacing,
      ).replace(/\s+$/, ''),
    )
    lines.push('\n'.repeat(lineSpacing))

    const weeks = months.map((month) => buildMonthCalendar(year, month))
    const height = Math.max(...weeks.map((calendarRows) => calendarRows.length))

    for (let weekIndex = 0; weekIndex < height; weekIndex += 1) {
      lines.push(
        formatString(
          weeks.map((calendarRows) =>
            weekIndex >= calendarRows.length
              ? ''
              : formatWeek(
                  (calendarRows[weekIndex] ?? []).map((day, weekday) => [day, weekday]),
                  width,
                ),
          ),
          monthWidth,
          columnSpacing,
        ).replace(/\s+$/, ''),
      )
      lines.push('\n'.repeat(lineSpacing))
    }
  }

  return lines.join('')
}

function daysBeforeYear(year) {
  const adjusted = year - 1
  return adjusted * 365 + Math.floor(adjusted / 4) - Math.floor(adjusted / 100) + Math.floor(adjusted / 400)
}

function daysBeforeMonth(year, month) {
  const offsets = isLeapYear(year)
    ? [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]
    : [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]
  return offsets[month - 1] ?? 0
}

function centerText(value, width) {
  if (width <= value.length) {
    return value
  }

  const leftPadding = Math.floor((width - value.length) / 2)
  const rightPadding = width - value.length - leftPadding
  return `${' '.repeat(leftPadding)}${value}${' '.repeat(rightPadding)}`
}

function positiveModulo(value, modulus) {
  return ((value % modulus) + modulus) % modulus
}

function isIterable(value) {
  return value !== null && value !== undefined && typeof value[Symbol.iterator] === 'function'
}

function centerMethodString(value, width) {
  if (typeof value !== 'string') {
    throw new AttributeError(`${value === null ? 'NoneType' : typeof value} object has no attribute 'center'`)
  }

  return centerText(value, width)
}

class AttributeError extends Error {
  constructor(message) {
    super(message)
    this.name = 'AttributeError'
  }
}

const normalizeCalendarYear = toCalendarInteger

// python/calendar/calendar (target function module)
function calendar(theyear, w = 2, l = 1, c = 6, m = 3) {
  //      discuss at: https://locutus.io/python/calendar/calendar/
  // parity verified: Python 3.12
  //     original by: Kevin van Zonneveld (https://kvz.io)
  //       example 1: calendar(2024)
  //       returns 1: '                                  2024\n\n      January                   February                   March\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n 1  2  3  4  5  6  7                1  2  3  4                   1  2  3\n 8  9 10 11 12 13 14       5  6  7  8  9 10 11       4  5  6  7  8  9 10\n15 16 17 18 19 20 21      12 13 14 15 16 17 18      11 12 13 14 15 16 17\n22 23 24 25 26 27 28      19 20 21 22 23 24 25      18 19 20 21 22 23 24\n29 30 31                  26 27 28 29               25 26 27 28 29 30 31\n\n       April                      May                       June\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n 1  2  3  4  5  6  7             1  2  3  4  5                      1  2\n 8  9 10 11 12 13 14       6  7  8  9 10 11 12       3  4  5  6  7  8  9\n15 16 17 18 19 20 21      13 14 15 16 17 18 19      10 11 12 13 14 15 16\n22 23 24 25 26 27 28      20 21 22 23 24 25 26      17 18 19 20 21 22 23\n29 30                     27 28 29 30 31            24 25 26 27 28 29 30\n\n        July                     August                  September\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n 1  2  3  4  5  6  7                1  2  3  4                         1\n 8  9 10 11 12 13 14       5  6  7  8  9 10 11       2  3  4  5  6  7  8\n15 16 17 18 19 20 21      12 13 14 15 16 17 18       9 10 11 12 13 14 15\n22 23 24 25 26 27 28      19 20 21 22 23 24 25      16 17 18 19 20 21 22\n29 30 31                  26 27 28 29 30 31         23 24 25 26 27 28 29\n                                                    30\n\n      October                   November                  December\nMo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n    1  2  3  4  5  6                   1  2  3                         1\n 7  8  9 10 11 12 13       4  5  6  7  8  9 10       2  3  4  5  6  7  8\n14 15 16 17 18 19 20      11 12 13 14 15 16 17       9 10 11 12 13 14 15\n21 22 23 24 25 26 27      18 19 20 21 22 23 24      16 17 18 19 20 21 22\n28 29 30 31               25 26 27 28 29 30         23 24 25 26 27 28 29\n                                                    30 31\n'

  if (arguments.length === 0) {
    throw new TypeError("TextCalendar.formatyear() missing 1 required positional argument: 'theyear'")
  }

  return formatYear(
    normalizeCalendarYear(theyear, 'calendar'),
    normalizeMonthWidth(w, 'calendar'),
    normalizeLineSpacing(l, 'calendar'),
    normalizeColumnSpacing(c, 'calendar'),
    normalizeMonthsPerRow(m, 'calendar'),
  )
}

Improve this function

Locutus is a community effort following The McDonald's Theory: we ship first iterations, hoping others will improve them. If you see something that could be better, we'd love your contribution.

View on GitHub · Edit on GitHub · View Raw

Help us add more

Got a rainy Sunday afternoon and a taste for a porting puzzle?

Get inspiration from the Python 3 standard library string page.
Click "New file" in the appropriate folder on GitHub. This will fork the project to your account, directly add the file to it, and send a Pull Request to us.

We will then review it. If it's useful to the project and in line with our contributing guidelines your work will become part of Locutus and you'll be automatically credited in the authors section accordingly.

« More Python calendar functions

Star