repaykit 1.0.0__py3-none-any.whl

repaykit/schedules/base.py

@@ -0,0 +1,48 @@
+"""Payment schedule interfaces."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Iterator
+from datetime import date
+from decimal import Decimal
+
+from repaykit.exceptions import ScheduleGenerationError
+from repaykit.terms import Term
+
+
+class PaymentSchedule(ABC):
+    frequency_name: str
+    periods_per_year: Decimal
+
+    @abstractmethod
+    def _next_due_date(self, start_date: date, period: int) -> date:
+        """Return the due date for a 1-based period."""
+
+    def iter_due_dates(self, start_date: date, term: Term) -> Iterator[date]:
+        if term.periods is not None:
+            for period in range(1, term.periods + 1):
+                yield self._next_due_date(start_date, period)
+            return
+
+        end_date = term.end_after(start_date)
+        period = 1
+        while True:
+            due_date = self._next_due_date(start_date, period)
+            if due_date > end_date:
+                break
+            yield due_date
+            period += 1
+            if period > 1_000_000:
+                raise ScheduleGenerationError("schedule exceeded the safety period limit")
+
+    def period_count(self, start_date: date, term: Term) -> int:
+        count = sum(1 for _ in self.iter_due_dates(start_date, term))
+        if count <= 0:
+            raise ScheduleGenerationError("term and schedule must produce at least one period")
+        return count
+
+    def term_years(self, start_date: date, term: Term) -> Decimal:
+        if term.periods is not None:
+            return Decimal(term.periods) / self.periods_per_year
+        return term.approximate_years(start_date)

repaykit/schedules/biweekly.py

@@ -0,0 +1,18 @@
+"""Biweekly repayment schedules."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date, timedelta
+from decimal import Decimal
+
+from repaykit.schedules.base import PaymentSchedule
+
+
+@dataclass(frozen=True, slots=True)
+class BiWeeklySchedule(PaymentSchedule):
+    frequency_name: str = "biweekly"
+    periods_per_year: Decimal = Decimal("26")
+
+    def _next_due_date(self, start_date: date, period: int) -> date:
+        return start_date + timedelta(weeks=period * 2)

repaykit/schedules/custom.py

@@ -0,0 +1,42 @@
+"""Custom explicit due-date schedules."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Sequence
+from dataclasses import dataclass
+from datetime import date
+from decimal import Decimal
+
+from repaykit.exceptions import ValidationError
+from repaykit.schedules.base import PaymentSchedule
+from repaykit.terms import Term
+
+
+@dataclass(frozen=True, slots=True)
+class CustomSchedule(PaymentSchedule):
+    dates: Sequence[date]
+    frequency_name: str = "custom"
+    periods_per_year: Decimal = Decimal("12")
+
+    def __post_init__(self) -> None:
+        if not self.dates:
+            raise ValidationError("custom schedule requires at least one date")
+        if list(self.dates) != sorted(self.dates):
+            raise ValidationError("custom schedule dates must be sorted")
+        if len(set(self.dates)) != len(self.dates):
+            raise ValidationError("custom schedule dates must be unique")
+
+    def _next_due_date(self, start_date: date, period: int) -> date:
+        return self.dates[period - 1]
+
+    def iter_due_dates(self, start_date: date, term: Term) -> Iterator[date]:
+        limit = term.periods if term.periods is not None else len(self.dates)
+        for due_date in self.dates[:limit]:
+            if due_date <= start_date:
+                raise ValidationError("custom schedule dates must be after start_date")
+            if term.end_date is not None and due_date > term.end_date:
+                break
+            yield due_date
+
+    def period_count(self, start_date: date, term: Term) -> int:
+        return sum(1 for _ in self.iter_due_dates(start_date, term))

repaykit/schedules/daily.py

@@ -0,0 +1,28 @@
+"""Daily repayment schedules."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date, timedelta
+from decimal import Decimal
+
+from repaykit.schedules.base import PaymentSchedule
+
+
+@dataclass(frozen=True, slots=True)
+class DailySchedule(PaymentSchedule):
+    include_weekends: bool = True
+    frequency_name: str = "daily"
+    periods_per_year: Decimal = Decimal("365")
+
+    def _next_due_date(self, start_date: date, period: int) -> date:
+        if self.include_weekends:
+            return start_date + timedelta(days=period)
+
+        current = start_date
+        business_days = 0
+        while business_days < period:
+            current += timedelta(days=1)
+            if current.weekday() < 5:
+                business_days += 1
+        return current

repaykit/schedules/monthly.py

@@ -0,0 +1,29 @@
+"""Monthly repayment schedules with month-end safety."""
+
+from __future__ import annotations
+
+import calendar
+from dataclasses import dataclass
+from datetime import date
+from decimal import Decimal
+
+from repaykit.schedules.base import PaymentSchedule
+
+
+def add_months(value: date, months: int, *, day: int | None = None) -> date:
+    month_index = value.month - 1 + months
+    year = value.year + month_index // 12
+    month = month_index % 12 + 1
+    target_day = value.day if day is None else day
+    last_day = calendar.monthrange(year, month)[1]
+    return date(year, month, min(target_day, last_day))
+
+
+@dataclass(frozen=True, slots=True)
+class MonthlySchedule(PaymentSchedule):
+    day: int | None = None
+    frequency_name: str = "monthly"
+    periods_per_year: Decimal = Decimal("12")
+
+    def _next_due_date(self, start_date: date, period: int) -> date:
+        return add_months(start_date, period, day=self.day)

repaykit/schedules/quarterly.py

@@ -0,0 +1,20 @@
+"""Quarterly repayment schedules."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date
+from decimal import Decimal
+
+from repaykit.schedules.base import PaymentSchedule
+from repaykit.schedules.monthly import add_months
+
+
+@dataclass(frozen=True, slots=True)
+class QuarterlySchedule(PaymentSchedule):
+    day: int | None = None
+    frequency_name: str = "quarterly"
+    periods_per_year: Decimal = Decimal("4")
+
+    def _next_due_date(self, start_date: date, period: int) -> date:
+        return add_months(start_date, period * 3, day=self.day)

repaykit/schedules/weekly.py

@@ -0,0 +1,23 @@
+"""Weekly repayment schedules."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date, timedelta
+from decimal import Decimal
+
+from repaykit.schedules.base import PaymentSchedule
+
+
+@dataclass(frozen=True, slots=True)
+class WeeklySchedule(PaymentSchedule):
+    weekday: int | None = None
+    frequency_name: str = "weekly"
+    periods_per_year: Decimal = Decimal("52")
+
+    def _next_due_date(self, start_date: date, period: int) -> date:
+        if self.weekday is None:
+            return start_date + timedelta(weeks=period)
+        first = start_date + timedelta(days=1)
+        days_until = (self.weekday - first.weekday()) % 7
+        return first + timedelta(days=days_until + (period - 1) * 7)

repaykit/schedules/yearly.py

@@ -0,0 +1,20 @@
+"""Yearly repayment schedules."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date
+from decimal import Decimal
+
+from repaykit.schedules.base import PaymentSchedule
+from repaykit.schedules.monthly import add_months
+
+
+@dataclass(frozen=True, slots=True)
+class YearlySchedule(PaymentSchedule):
+    day: int | None = None
+    frequency_name: str = "yearly"
+    periods_per_year: Decimal = Decimal("1")
+
+    def _next_due_date(self, start_date: date, period: int) -> date:
+        return add_months(start_date, period * 12, day=self.day)

repaykit/terms/__init__.py

@@ -0,0 +1,5 @@
+"""Term models."""
+
+from repaykit.terms.term import Term
+
+__all__ = ["Term"]

repaykit/terms/term.py

@@ -0,0 +1,85 @@
+"""Loan term modeling and parsing."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from datetime import date, timedelta
+from decimal import Decimal
+
+from repaykit.exceptions import ValidationError
+
+_TERM_RE = re.compile(
+    r"^\s*(?P<count>\d+)\s*"
+    r"(?P<unit>day|days|week|weeks|month|months|year|years|period|periods)\s*$"
+)
+
+
+@dataclass(frozen=True, slots=True)
+class Term:
+    days: int | None = None
+    weeks: int | None = None
+    months: int | None = None
+    years: int | None = None
+    periods: int | None = None
+    end_date: date | None = None
+
+    def __post_init__(self) -> None:
+        values = [self.days, self.weeks, self.months, self.years, self.periods, self.end_date]
+        if sum(value is not None for value in values) != 1:
+            raise ValidationError("exactly one term dimension must be provided")
+        for name in ("days", "weeks", "months", "years", "periods"):
+            value = getattr(self, name)
+            if value is not None and value <= 0:
+                raise ValidationError(f"term {name} must be positive")
+
+    @classmethod
+    def parse(cls, value: str | Term) -> Term:
+        if isinstance(value, Term):
+            return value
+        match = _TERM_RE.match(value)
+        if not match:
+            raise ValidationError("term must look like '24 months', '52 weeks', or '10 periods'")
+        count = int(match.group("count"))
+        unit = match.group("unit")
+        if unit.startswith("day"):
+            return cls(days=count)
+        if unit.startswith("week"):
+            return cls(weeks=count)
+        if unit.startswith("month"):
+            return cls(months=count)
+        if unit.startswith("year"):
+            return cls(years=count)
+        return cls(periods=count)
+
+    def approximate_years(self, start_date: date | None = None) -> Decimal:
+        if self.days is not None:
+            return Decimal(self.days) / Decimal("365")
+        if self.weeks is not None:
+            return Decimal(self.weeks) / Decimal("52")
+        if self.months is not None:
+            return Decimal(self.months) / Decimal("12")
+        if self.years is not None:
+            return Decimal(self.years)
+        if self.end_date is not None:
+            if start_date is None:
+                raise ValidationError("start_date is required for end_date terms")
+            return Decimal((self.end_date - start_date).days) / Decimal("365")
+        raise ValidationError("period-based terms need a schedule to infer years")
+
+    def end_after(self, start_date: date) -> date:
+        if self.days is not None:
+            return start_date + timedelta(days=self.days)
+        if self.weeks is not None:
+            return start_date + timedelta(weeks=self.weeks)
+        if self.months is not None:
+            from repaykit.schedules.monthly import add_months
+
+            return add_months(start_date, self.months)
+        if self.years is not None:
+            from repaykit.schedules.monthly import add_months
+
+            return add_months(start_date, self.years * 12)
+        if self.end_date is not None:
+            return self.end_date
+        raise ValidationError("period-based terms do not have a calendar end without a schedule")

repaykit-1.0.0.dist-info/METADATA

@@ -0,0 +1,285 @@
+Metadata-Version: 2.4
+Name: repaykit
+Version: 1.0.0
+Summary: Pure Python repayment schedule, financing, loan ledger, and settlement calculation toolkit.
+Project-URL: Homepage, https://github.com/finsure-techlab/repaykit
+Project-URL: Repository, https://github.com/finsure-techlab/repaykit
+Project-URL: Issues, https://github.com/finsure-techlab/repaykit/issues
+Author: finsure techlab
+License-Expression: MIT
+License-File: LICENSE
+Keywords: amortization,financing,ledger,loan,repayment,settlement
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: coverage; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# repaykit
+
+Pure Python repayment schedule, financing, loan ledger, and settlement calculation toolkit.
+
+`repaykit` helps software teams calculate loan and financing schedules, payment ledgers, late
+charges, statement balances, and settlement quotes. It is framework-agnostic, uses `Decimal` for
+money and rates, and keeps business rules policy-driven.
+
+## What It Is Not
+
+`repaykit` is not a loan origination system, accounting system, regulatory compliance engine, or
+legal opinion. It does not provide legal, accounting, tax, Shariah, regulatory, lending, or
+financial advice. Users are responsible for validating calculations, policies, disclosures, and
+compliance requirements for their jurisdiction and product.
+
+## Installation
+
+```bash
+pip install repaykit
+```
+
+## Supported Methods
+
+- Flat rate
+- Sum-of-digits / Rule of 78
+- Reducing balance amortization
+- Constant principal repayment
+
+## Supported Schedules
+
+- Daily, with optional weekend skipping
+- Weekly
+- Biweekly
+- Monthly, with month-end safety
+- Quarterly
+- Yearly
+- Custom explicit due dates
+
+## Quickstart
+
+```python
+from datetime import date
+from decimal import Decimal
+
+from repaykit import Loan
+
+loan = Loan.create(
+    amount=Decimal("10000.00"),
+    annual_rate=Decimal("0.08"),
+    term="24 months",
+    payment_frequency="monthly",
+    method="flat_rate",
+    start_date=date(2026, 6, 1),
+)
+
+payment = loan.payment_amount()
+rows = loan.schedule()
+```
+
+Use `iter_schedule()` for lazy row generation, especially for daily schedules.
+
+## Expert Mode
+
+```python
+from datetime import date
+from decimal import Decimal
+
+from repaykit import Loan
+from repaykit.accruals import FlatAccrual
+from repaykit.methods import FlatRateAllocation
+from repaykit.policies import RoundingPolicy
+from repaykit.schedules import MonthlySchedule
+from repaykit.terms import Term
+
+loan = Loan(
+    principal=Decimal("10000.00"),
+    term=Term(months=24),
+    payment_schedule=MonthlySchedule(day=1),
+    accrual_policy=FlatAccrual(annual_rate=Decimal("0.08")),
+    repayment_method=FlatRateAllocation(),
+    rounding=RoundingPolicy(currency="MYR"),
+    start_date=date(2026, 6, 1),
+)
+```
+
+## Flat Rate Example
+
+```python
+loan = Loan.create(
+    amount=Decimal("10000.00"),
+    annual_rate=Decimal("0.08"),
+    term="24 months",
+    payment_frequency="monthly",
+    method="flat_rate",
+    start_date=date(2026, 6, 1),
+)
+```
+
+Flat-rate total profit is `principal * annual_rate * term_in_years`. Future scheduled profit is
+treated as unearned profit rebate in the default settlement policy.
+
+## Sum-of-Digits / Rule of 78 Example
+
+```python
+loan = Loan.create(
+    amount=Decimal("10000.00"),
+    annual_rate=Decimal("0.08"),
+    term="12 months",
+    payment_frequency="monthly",
+    method="sum_of_digits",
+    start_date=date(2026, 1, 1),
+)
+```
+
+The denominator is generalized as `n * (n + 1) / 2`, so the method works with non-monthly period
+counts such as 52 weekly periods.
+
+## Reducing Balance Example
+
+```python
+loan = Loan.create(
+    amount=Decimal("10000.00"),
+    annual_rate=Decimal("0.08"),
+    term="24 months",
+    payment_frequency="monthly",
+    method="reducing_balance",
+    start_date=date(2026, 6, 1),
+)
+```
+
+Reducing balance uses fixed-payment amortization. Profit is calculated on the outstanding balance
+for each period.
+
+## Constant Principal Example
+
+```python
+loan = Loan.create(
+    amount=Decimal("10000.00"),
+    annual_rate=Decimal("0.08"),
+    term="24 months",
+    payment_frequency="monthly",
+    method="constant_principal",
+    start_date=date(2026, 6, 1),
+)
+```
+
+The principal component is constant except for the final rounding adjustment; installments decline
+as profit declines.
+
+## Weekly Payment Example
+
+```python
+loan = Loan.create(
+    amount=Decimal("5000.00"),
+    annual_rate=Decimal("0.10"),
+    term="52 weeks",
+    payment_frequency="weekly",
+    method="constant_principal",
+    start_date=date(2026, 1, 1),
+)
+```
+
+## Daily Payment Example
+
+```python
+loan = Loan.create(
+    amount=Decimal("1000.00"),
+    annual_rate=Decimal("0.12"),
+    term="30 days",
+    payment_frequency="daily",
+    method="reducing_balance",
+    start_date=date(2026, 1, 1),
+)
+```
+
+## Payment Ledger Example
+
+```python
+from repaykit import LoanAccount
+
+account = LoanAccount(loan)
+account.add_payment(
+    amount=Decimal("500.00"),
+    paid_at=date(2026, 7, 5),
+    reference="ANGKASA-JULY-2026",
+)
+
+statement = account.statement(as_of=date(2026, 8, 1))
+print(statement.total_due)
+print(statement.total_paid)
+print(statement.arrears)
+print(statement.outstanding_balance)
+```
+
+Statements use aggregate oldest-due-first allocation for due installments and late-charge exposure.
+They do not maintain a double-entry accounting ledger or split each payment into principal/profit
+transactions.
+
+## Late Charge Example
+
+```python
+from repaykit.policies import LateChargePolicy
+
+loan.late_charge_policy = LateChargePolicy(
+    rate=Decimal("0.01"),
+    grace_days=5,
+    basis="flat",
+    minimum_charge=Decimal("0.00"),
+)
+```
+
+Supported bases are `flat` and `daily`. Negative overdue amounts are treated as zero.
+
+## Settlement Example
+
+```python
+settlement = account.full_settlement(as_of=date(2026, 12, 15))
+
+print(settlement.outstanding_principal)
+print(settlement.unearned_profit_rebate)
+print(settlement.late_charges)
+print(settlement.amount_payable)
+print(settlement.explanation)
+```
+
+Settlement is policy-based. Flat-rate and sum-of-digits methods rebate future scheduled profit by
+default. Reducing-balance and constant-principal methods have no unearned profit rebate by default.
+Validate settlement behavior against your contract and regulatory requirements.
+
+## Export Example
+
+```python
+from repaykit.exporters import schedule_to_csv, schedule_to_dicts
+
+rows = loan.schedule()
+data = schedule_to_dicts(rows)
+schedule_to_csv(rows, "schedule.csv")
+```
+
+Exporters serialize `Decimal` values as strings and dates as ISO strings. They never convert money
+to floats.
+
+## Rounding Warning
+
+The default `RoundingPolicy` uses half-up money rounding with two decimal places. Different
+institutions and jurisdictions may require different rounding points, decimal places, or settlement
+rebate rules. Configure and test policies against the governing contract and regulation.
+
+## Release Status
+
+Version 1.0.0 declares the public API documented in `docs/api.md`. Breaking public API changes
+after 1.0.0 require a major version bump.

repaykit-1.0.0.dist-info/RECORD

@@ -0,0 +1,48 @@
+repaykit/__init__.py,sha256=QJaAEmjbK5g4QHON4wScHZFuDuVjh2iEo0vGinE53nw,396
+repaykit/_serialization.py,sha256=8r_QQAUe8GzLL0s6Rd5kP2CId6UE8-TQFBvEyk_iUS4,986
+repaykit/account.py,sha256=yeO7jpEySMwq963OuxUWMY_V2W-jVtv4xTno_AXWITg,3610
+repaykit/enums.py,sha256=DGotvaPfhdD-F1Ew_C9f55jYYoGndjuNkmltysye9mk,486
+repaykit/exceptions.py,sha256=yJdh4zbrqF570Jy-j1FrDsLh6RM3WZVnkTyPiWIeabg,546
+repaykit/loan.py,sha256=jBnvmK4pIIwzY09TQ8QwsVeVchhdMv2iHr-feUDwkCU,5532
+repaykit/money.py,sha256=x9ioaQpJ986Xvirlo-2WlOdrdNNuX7o2Qd-bzpzqfLw,1055
+repaykit/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+repaykit/results.py,sha256=dAAFQwxLTGyEnQ9tZHBnzwzoE6Mc9YIyk1hRD2griBQ,1396
+repaykit/accruals/__init__.py,sha256=ljnWLm4xW-FZ6OV2l_IliYHvoeIQIRjps-uhbNRYQL8,304
+repaykit/accruals/base.py,sha256=0dKEvwiuO_3Ly6CE8UwZaNXejt9oxzQMyWBpeq5Mmvg,829
+repaykit/accruals/daily.py,sha256=ypiT2ozzE3363-f9ZGQACMGyVfNkqVJJ1nhtTsHRK80,517
+repaykit/accruals/flat.py,sha256=Rxw9lGcBRSpFJFcFqOiH5ILzf5Nyn0W7cCWmjAn8Vx8,385
+repaykit/accruals/periodic.py,sha256=79PMntB4gM3E1a9oLhry5iA3k3ubVPjygLghnaI_sHk,249
+repaykit/backends/README.md,sha256=04oE8uy9xOphuhQWLlYRah9iwH0FvpeWDMvMQ3_vetc,576
+repaykit/exporters/__init__.py,sha256=oQ-p5ey3KOomEGWOgMWo2Levi5Iztj8lttFfrFIfiHQ,298
+repaykit/exporters/csv.py,sha256=8X2ZOA86nm3qiHAnQ0giZ8SxeoqRkxtZJm-XchOg6AY,829
+repaykit/exporters/dicts.py,sha256=Xus6vhSNJ1y5Syd8tCcdfTWcTBgpyJanbIZ-hbjh-rE,414
+repaykit/ledger/__init__.py,sha256=j4eTVRLN5BRHQV-Tlz_a11YlDxNVCKUgP-yN4uQXiwQ,234
+repaykit/ledger/account_statement.py,sha256=Kut4diYKlC4I7bIk636n8zNSKLmvQyLylAXDGwKKIDg,90
+repaykit/ledger/payment.py,sha256=EpIzCwIji2NyrIPmkUBtlV5Wmu74UzgDc26g0LsJMb8,763
+repaykit/ledger/transaction.py,sha256=p7jh3HAnMdp9HjhkYPtl34vfUaGZSjWlquwzxukmbWY,395
+repaykit/methods/__init__.py,sha256=8XDe6ulQkXFhMsE0XBgo_W4XWXd4f4DOdHvJrIOqOWQ,519
+repaykit/methods/base.py,sha256=mFz2J8_tkO4T7KR_RBQuJuwZHbA-KRRtB7YZAtCGsGI,1232
+repaykit/methods/constant_principal.py,sha256=LHGsWQJe3xiXTWa71uCfU7f2XDyvNibcDrS2nSXL19g,2694
+repaykit/methods/flat_rate.py,sha256=g6ePHj6vXrDgf8MAI62X7fRwWhxqcsHd29bRf4MDLGU,3273
+repaykit/methods/reducing_balance.py,sha256=FFl7P7_itUwMSPHajT2t-iuPTyEM-dcXDchdnTujlis,3031
+repaykit/methods/sum_of_digits.py,sha256=lnwfjEBSFa34YgRCG89L927Cp45uJVNpFtRGJZrzq-Y,3776
+repaykit/policies/__init__.py,sha256=9xNvFq2zaaVazYK93c0SFTRwocnYUrmJzQsdNwZ3POI,472
+repaykit/policies/allocation.py,sha256=vEjbNFmUKmGLjvRaGlpJaiLmoDssLcAVTxuuN6UNoqk,470
+repaykit/policies/late_charge.py,sha256=BjRY6qwI3_uS0KU_b5r6MXZo8macNJGsqc7ensrfSDM,2335
+repaykit/policies/rounding.py,sha256=o3RvO3R-zScZYa646reTzDKkCIg2MxyTdE0d3tbyH88,1162
+repaykit/policies/settlement.py,sha256=P59kTA8na3yN38SYlaZpszG3WgsvzIJAUvAgGH_2Qkk,2761
+repaykit/schedules/__init__.py,sha256=-5MjkzSxjl3YzlBDPdlXAla4iy4y_JFH46b8rNHX2r0,666
+repaykit/schedules/base.py,sha256=WGhEOBFugfoCsAATTeqxTKFZQed9QEKI_239CeRKA9M,1649
+repaykit/schedules/biweekly.py,sha256=rveKnZWTQ2JzUtt0XJbDvbKRsnxTMh08ZrPmnnbLcTc,513
+repaykit/schedules/custom.py,sha256=0UHfBCrRF_Mz2RtUA0hvmEhMn4Xwg99JuH-fOXQtruA,1618
+repaykit/schedules/daily.py,sha256=M8W8_TmU0ObxLk1OeRdpIyBFaU5aK4iUHb9vN-Nj9wE,803
+repaykit/schedules/monthly.py,sha256=mGSsa20idY6PL5L2yG_9AAjzREJ9-QLU2zHsrKoAiHo,923
+repaykit/schedules/quarterly.py,sha256=5KM1OHwoZnExyiQqEJ0UeY52xFh-q24bImv3TuBPBo8,589
+repaykit/schedules/weekly.py,sha256=ZOJNbQPlbzNP4JqSQq40iz4wwaLhf2iWl_NbbiEudAE,745
+repaykit/schedules/yearly.py,sha256=TwhqKFQmAqTXZsSEf_fh1FDZsgIfsrdAvUtaDBgjfKk,581
+repaykit/terms/__init__.py,sha256=OUHH5w461gkj2R7WC41QYuFLf8JcaACFAsXXmALsHTQ,77
+repaykit/terms/term.py,sha256=DxV_sq-BrPoqCurM4CyPqhQcgj33vw8V8a80vq83XRg,3243
+repaykit-1.0.0.dist-info/METADATA,sha256=poamC3RSXpbuqHi5tFYFGlXGgwMzaSznjU-nQRHzrxU,7821
+repaykit-1.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+repaykit-1.0.0.dist-info/licenses/LICENSE,sha256=AeIppiqUtmEGOHqm3coSzkOOcT6XJipw4-BEcMfpdwk,1072
+repaykit-1.0.0.dist-info/RECORD,,

repaykit-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any