DEV Community: lenevo02487

GST Invoice Math in Pure Python — CGST, SGST, IGST Explained with Code

lenevo02487 — Mon, 02 Nov 2026 11:06:49 +0000

If you've ever built billing software for India, you've hit the question: when does GST split into CGST + SGST, and when is it a single IGST? Get it wrong and the invoice is wrong — even if the total looks right.

I built a small GST invoice generator in pure Python (standard library only) to get this math exactly right. Here's the logic, with a real worked example whose grand total is ₹15,522.

The one rule that decides everything

Compare two state codes:

Seller's state code == place-of-supply state code → intra-state → tax splits in half: CGST + SGST
They differ → inter-state → one single tax: IGST

That's it. The customer's address doesn't decide it — the place of supply does (for goods, usually where they're delivered). In code:

intra = shop_state_code == place_of_supply_state_code

Per-line math

For each item: taxable = qty × rate, then tax = taxable × GST%. The split is where people slip:

from decimal import Decimal, ROUND_HALF_UP

D = Decimal
CENT = D("0.01")

def money(x):
    """Round to 2 decimals, half-up (the way shops actually bill)."""
    return D(x).quantize(CENT, rounding=ROUND_HALF_UP)

taxable = money(qty * rate)
tax = money(taxable * gst_percent / 100)

if intra:
    cgst = money(tax / 2)
    sgst = tax - cgst          # <-- the important line
    igst = D("0")
else:
    cgst = sgst = D("0")
    igst = tax

Two things to notice:

1. Never use floats for money. 0.1 + 0.2 != 0.3 in floating point, and those errors will surface on an invoice. Decimal with explicit half-up rounding is how real billing works.

2. The odd-paisa trick. Splitting ₹111.75 in half gives ₹55.875 — not a real amount. Round one half up (CGST ₹55.88) and set the other half to tax − cgst (SGST ₹55.87), so the two halves always add back to the exact tax. If you round both halves independently, invoices drift by a paisa and accountants come looking for you.

The worked example (real output)

An intra-state invoice — seller and place of supply in the same state — with five items at three different GST rates:

Item	Qty	Rate	GST	Taxable	Tax
CTC Tea (1 kg)	10	₹420	5%	₹4,200.00	₹210.00
Earthen Cups (pack of 12)	20	₹60	12%	₹1,200.00	₹144.00
Chai Masala Combo Pack	15	₹149	5%	₹2,235.00	₹111.75
Electric Kettle 1.8L	3	₹1,299	18%	₹3,897.00	₹701.46
LED Bulb 9W (set of 4)	8	₹299	18%	₹2,392.00	₹430.56

Because it's intra-state, every tax above splits into CGST + SGST halves — including the chai masala's ₹111.75, which becomes CGST ₹55.88 + SGST ₹55.87 (spot the odd-paisa trick doing its job).

Tax summary by rate (this grouping is what goes on the invoice and into GST returns):

GST rate	Taxable value	CGST	SGST	Total tax
5% (2.5% + 2.5%)	₹6,435.00	₹160.88	₹160.87	₹321.75
12% (6% + 6%)	₹1,200.00	₹72.00	₹72.00	₹144.00
18% (9% + 9%)	₹6,289.00	₹566.01	₹566.01	₹1,132.02

Totals:

Subtotal (taxable value)   ₹13,924.00
Total GST                  ₹ 1,597.77
Grand total                ₹15,521.77  →  rounded ₹15,522 (round-off +₹0.23)

If the same five items were supplied to a customer in a different state, nothing about the taxable values changes — the same ₹1,597.77 simply appears as IGST instead of the CGST/SGST split, and the total stays ₹15,522. Same money, different tax heads — which is exactly why getting the split right matters for filing, not for the customer.

One more detail: the round-off

Invoices are paid in whole rupees, so the generator rounds the grand total (₹15,521.77 → ₹15,522) and shows the +₹0.23 round-off as its own line. Hiding the difference inside an item rate is how totals stop reconciling — display it openly instead.

Full code

The complete generator — JSON or CSV in, print-ready HTML invoice out, with a per-rate tax summary and the amount in words (Indian numbering: lakh/crore) — is on GitHub: gst-invoice-generator. Run it with the bundled sample and you'll get exactly the ₹15,522 invoice above.

Demo first — on YOUR sample — before you pay anything. Need invoice automation, spreadsheet cleanup, or a scraping/automation tool for your business? Send me a sample of your data and I'll show you a working demo first.

👉 My Python web scraping & automation gig on Fiverr

— Abhishek, Python Automation Developer

I Scraped a 1,000-Book Catalogue with Python — Full Walkthrough

lenevo02487 — Mon, 02 Nov 2026 11:04:52 +0000

Every web scraping tutorial stops at "here's how to grab one page." Real catalogues don't fit on one page — so for this practice project I scraped the entire books.toscrape.com catalogue: 1,000 books across 50 pages, into one clean CSV with title, price, star rating, and stock status.

books.toscrape.com exists specifically for scraping practice, which makes it the perfect place to learn the full workflow — pagination included. Here's exactly how it works, with the real code.

What we're building

A script that:

Opens the catalogue's first page
Extracts every book card on the page
Follows the "next" link until there isn't one
Writes everything to books.csv

Final output (real rows from the run):

title,price_gbp,rating,availability
A Light in the Attic,51.77,3,In stock
Tipping the Velvet,53.74,1,In stock
Soumission,50.10,1,In stock

Setup

pip install requests beautifulsoup4

That's it. No browser automation, no Selenium — the site serves plain HTML, so requests + BeautifulSoup is enough. Reaching for a headless browser when the HTML is right there is the most common beginner mistake I see.

Step 1: Understand one book card

Every book on the site lives in an <article class="product_pod"> element. Inside it:

the title is in the title attribute of the <h3><a> link (the visible text is truncated with "…", the attribute has the full title — grab the attribute!)
the price is in .price_color
the rating is a word — One to Five — hidden in the class list of .star-rating
availability is the text of .availability

RATING_WORDS = {"One": 1, "Two": 2, "Three": 3, "Four": 4, "Five": 5}

def parse_book(article):
    """Pull title, price, rating and availability out of one book card."""
    title = article.h3.a["title"]
    price = article.select_one(".price_color").get_text(strip=True)
    rating_word = article.select_one(".star-rating")["class"][1]
    availability = article.select_one(".availability").get_text(strip=True)
    return {
        "title": title,
        "price_gbp": price.replace("£", ""),
        "rating": RATING_WORDS.get(rating_word, ""),
        "availability": availability,
    }

Step 2: Follow the pagination

Instead of guessing page URLs (page-2.html, page-3.html…), let the site tell you where to go next. Each page has a li.next a link — follow it until it disappears:

import time
import requests
from bs4 import BeautifulSoup

BASE = "https://books.toscrape.com/"

def scrape(max_pages=None):
    books = []
    page_url = BASE
    page_no = 0
    session = requests.Session()
    session.headers["User-Agent"] = "Mozilla/5.0 (demo scraper)"

    while page_url:
        page_no += 1
        resp = session.get(page_url, timeout=25)
        resp.raise_for_status()
        resp.encoding = "utf-8"  # see lesson 1 below

        soup = BeautifulSoup(resp.text, "html.parser")
        for article in soup.select("article.product_pod"):
            books.append(parse_book(article))
        print(f"page {page_no}: {len(books)} books so far")

        if max_pages and page_no >= max_pages:
            break
        next_link = soup.select_one("li.next a")
        page_url = requests.compat.urljoin(page_url, next_link["href"]) if next_link else None
        if page_url:
            time.sleep(0.3)  # be polite to the server

    return books

Two details matter here:

urljoin — the next-page href is relative (catalogue/page-2.html), and urljoin resolves it correctly against whatever page you're on. Concatenating strings by hand breaks the moment the site structure changes.
The small sleep — 0.3s between pages costs you 15 seconds over 50 pages and keeps you a good citizen. On real projects this matters even more.

Step 3: Write the CSV

import csv

books = scrape()
with open("books.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["title", "price_gbp", "rating", "availability"])
    writer.writeheader()
    writer.writerows(books)

print(f"Done: {len(books)} books written to books.csv")

Output: Done: 1000 books written to books.csv — exactly 1,000, which matches the catalogue's own count. Always check your row count against a number the site itself reports; "it ran without errors" is not the same as "it got everything."

3 lessons this project teaches

1. Encoding will bite you. The site is UTF-8, but requests sometimes guesses Latin-1 from the headers — and the £ sign turns into Â£ in your CSV. One line (resp.encoding = "utf-8") fixes it. I found this the fun way: by opening the CSV.

2. Attributes beat visible text. The visible title is cut off ("A Light in the …"); the full title sits in the title attribute. When scraped data looks truncated, inspect the element before blaming your code.

3. Ratings hide in class names. There's no "3 stars" text anywhere — the rating is a CSS class. Real sites hide data in classes, data attributes, and JSON blobs all the time; reading the raw HTML is a core scraping skill.

Full code

The complete script (with a --pages flag for quick tests) is on GitHub: python-web-scraper — the repo includes the actual books.csv output with all 1,000 rows.

Demo first — on YOUR sample — before you pay anything. That's how I work: if you need a catalogue, price list, or directory scraped, send me the site and a few rows of the output you want, and I'll build a small working demo on your sample before you spend anything.

👉 My Python web scraping & automation gig on Fiverr

— Abhishek, Python Automation Developer