DEV Community: BlackyDoe

MedSpeak

BlackyDoe — Thu, 23 Jul 2026 16:04:14 +0000

When I first built MedSpeak, you had to type the shorthand in by hand. That's fine for a demo, but the whole point of a label is that it's already written down — so the natural next step was letting people snap a photo of the label and skip typing entirely.

This update adds in-browser OCR via Tesseract.js, switches the page to a JSON API instead of form posts, and keeps everything else — the lookup tables, the decoding logic — exactly the same.

1. What changed under the hood

The translation logic (decode(), and the FREQUENCY/TIMING/ROUTE/FORM tables) is untouched from the original version. What changed is how text gets into that function and how the result gets back to the page:

The form no longer does a full-page POST — a small fetch() call hits a JSON API instead
A file input lets you pick or snap a photo
Tesseract.js runs OCR on that photo entirely in the browser — no image ever gets uploaded to the server
Whatever text Tesseract finds gets dropped into the input box and decoded automatically

def do_POST(self):
    if self.path == "/api/decode":
        length = int(self.headers.get("Content-Length", 0))
        data = json.loads(self.rfile.read(length) or "{}")
        text = data.get("text", "")
        result = decode(text)
        self._send(200, json.dumps({"result": result}))
    else:
        self._send(404, "{}")

The server now speaks JSON in and JSON out, rather than parsing form-encoded bodies and re-rendering full HTML pages.

2. Calling the API from the page

Instead of a <form> submission, a plain fetch() call sends the current input value and updates the result div with whatever comes back.

async function go(){
  const text = document.getElementById('rx').value;
  const out = document.getElementById('out');
  if(!text.trim()){ return; }
  const res = await fetch('/api/decode', {
    method: 'POST',
    headers: {'Content-Type':'application/json'},
    body: JSON.stringify({text: text})
  });
  const data = await res.json();
  out.classList.remove('empty');
  out.innerHTML = '<span class="tag">Instructions</span>' + data.result;
}

This is what makes the page feel instant — no full-page reload, just the label card updating in place.

3. Reading text out of a photo

This is the new piece. Tesseract.js is loaded from a CDN and does OCR fully client-side:

<script src="https://cdnjs.cloudflare.com/ajax/libs/tesseract.js/5.0.4/tesseract.min.js"></script>

When a file is picked, it's previewed immediately and handed off to the OCR function:

function handleImage(event){
  const file = event.target.files[0];
  if (!file) return;
  const preview = document.getElementById('preview');
  preview.src = URL.createObjectURL(file);
  preview.style.display = 'block';
  scanImage(file);
}

URL.createObjectURL(file) creates a temporary local URL for the image so it can be shown in an <img> tag without ever leaving the browser.

4. Running OCR and feeding the result back in

async function scanImage(file){
  const status = document.getElementById('scanStatus');
  status.innerText = "Reading text from image...";
  try {
    const result = await Tesseract.recognize(file, 'eng');
    const rawText = result.data.text.trim();
    status.innerText = rawText ? ("Detected: " + rawText) : "No text found — try a clearer photo.";
    if (rawText){
      document.getElementById('rx').value = rawText.replace(/\n/g, ' ');
      go();
    }
  } catch(e){
    status.innerText = "Scan failed — type it manually instead.";
  }
}

Tesseract.recognize(file, 'eng') runs the whole OCR pipeline and returns detected text. Newlines get collapsed into spaces (since prescription shorthand is normally a single line), the input box gets populated, and go() — the same function used for manual typing — decodes it immediately.

5. The full script, start to end

import json
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

FREQUENCY = {
    "qd": "once a day", "od": "once a day",
    "bid": "twice a day",
    "tid": "three times a day",
    "qid": "four times a day",
    "qod": "every other day",
    "hs": "at bedtime",
    "stat": "immediately",
    "prn": "as needed",
    "am": "in the morning", "qam": "every morning",
    "pm": "in the evening", "qpm": "every evening",
}

TIMING = {
    "ac": "before meals",
    "pc": "after meals",
    "cc": "with meals",
}

ROUTE = {
    "po": "by mouth",
    "sl": "under the tongue",
    "iv": "by IV",
    "im": "as an injection into the muscle",
    "sc": "as an injection under the skin",
    "sq": "as an injection under the skin",
    "pr": "rectally",
    "top": "applied to the skin",
}

FORM = {
    "tab": "tablet", "tabs": "tablets",
    "cap": "capsule", "caps": "capsules",
    "ml": "ml",
    "mg": "mg",
    "gtt": "drop", "gtts": "drops",
}

def decode(text):
    tokens = text.replace(",", " ").split()
    result = []
    for tok in tokens:
        raw = tok.strip(".")
        low = raw.lower()

        if low.isdigit():
            result.append(f"Take {low}")
        elif low in FORM:
            result.append(FORM[low])
        elif low in FREQUENCY:
            result.append(FREQUENCY[low])
        elif low in TIMING:
            result.append(TIMING[low])
        elif low in ROUTE:
            result.append(ROUTE[low])
        elif low.startswith("q") and low.endswith("h") and low[1:-1].isdigit():
            hrs = low[1:-1]
            result.append(f"every {hrs} hours")
        else:
            result.append(raw)

    sentence = " ".join(result)
    return sentence[0].upper() + sentence[1:] if sentence else ""

HTML_PAGE = """
<!DOCTYPE html>
<html><head><meta charset="utf-8">
<title>MedSpeak</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link href="https://fonts.googleapis.com/css2?family=Lora:wght@500;600&family=Inter:wght@400;500;600&family=IBM+Plex+Mono:wght@500;600&display=swap" rel="stylesheet">
<script src="https://cdnjs.cloudflare.com/ajax/libs/tesseract.js/5.0.4/tesseract.min.js"></script>
<style>
  :root{
    --paper: #E8EDE6;
    --card: #FBFAF6;
    --ink: #1B2A4A;
    --ink-soft: #4A5A72;
    --amber: #C17817;
    --amber-deep: #9C5F10;
    --clay: #B3492B;
  }
  *{box-sizing:border-box}
  body{
    margin:0; padding:32px 16px 60px;
    background:var(--paper);
    background-image:
      radial-gradient(circle at 15% 8%, rgba(193,120,23,0.06), transparent 40%),
      radial-gradient(circle at 85% 90%, rgba(27,42,74,0.05), transparent 40%);
    font-family:'Inter', sans-serif;
    color:var(--ink);
    display:flex; justify-content:center;
  }
  main{width:100%; max-width:560px}

  .eyebrow{
    font-family:'IBM Plex Mono', monospace;
    font-size:12px; letter-spacing:0.12em; text-transform:uppercase;
    color:var(--amber-deep); font-weight:600;
  }
  h1{
    font-family:'Lora', serif; font-weight:600;
    font-size:clamp(28px, 5vw, 36px);
    margin:6px 0 4px; color:var(--ink);
  }
  .sub{ color:var(--ink-soft); font-size:15px; margin:0 0 28px; max-width:44ch; line-height:1.5}

  .rx-mark{
    display:inline-flex; align-items:center; justify-content:center;
    width:40px; height:40px; border-radius:10px;
    background:var(--ink); color:var(--paper);
    font-family:'Lora', serif; font-weight:600; font-size:20px;
    margin-bottom:14px;
  }

  .card{
    background:var(--card); border-radius:14px; padding:22px;
    box-shadow:0 1px 2px rgba(27,42,74,0.06), 0 8px 24px rgba(27,42,74,0.05);
    border:1px solid rgba(27,42,74,0.08);
  }

  label.field-label{
    display:block; font-size:13px; font-weight:600; color:var(--ink-soft);
    margin-bottom:6px;
  }

  input[type=text]{
    width:100%; padding:12px 14px; font-size:16px;
    border-radius:8px; border:1.5px solid rgba(27,42,74,0.18);
    font-family:'IBM Plex Mono', monospace; background:#fff; color:var(--ink);
  }
  input[type=text]:focus{
    outline:3px solid rgba(193,120,23,0.35); outline-offset:1px;
    border-color:var(--amber);
  }

  .row{ display:flex; gap:10px; margin-top:12px }
  .row input{flex:1}

  button{
    padding:12px 20px; font-size:15px; font-weight:600;
    border:none; border-radius:8px; cursor:pointer;
    background:var(--amber); color:#fff;
    font-family:'Inter', sans-serif;
    transition:background .15s ease;
  }
  button:hover{ background:var(--amber-deep) }
  button:focus-visible{ outline:3px solid var(--ink); outline-offset:2px }

  .examples{ font-size:13px; color:var(--ink-soft); margin-top:10px }
  .examples code{
    font-family:'IBM Plex Mono', monospace; background:rgba(27,42,74,0.06);
    padding:2px 6px; border-radius:4px;
  }

  .label-wrap{ margin-top:26px }
  .rx-label{
    position:relative;
    background:#fff;
    border:1.5px solid rgba(27,42,74,0.15);
    border-radius:2px;
    padding:18px 18px 16px;
    font-family:'IBM Plex Mono', monospace;
    font-size:15px; line-height:1.55; color:var(--ink);
    transform:rotate(-0.6deg);
    box-shadow:0 6px 16px rgba(27,42,74,0.10);
  }
  .rx-label::before{
    content:"";
    position:absolute; top:-1px; left:8px; right:8px; height:1px;
    background-image: repeating-linear-gradient(90deg, rgba(27,42,74,0.35) 0 6px, transparent 6px 12px);
  }
  .rx-label .tag{
    font-family:'Inter', sans-serif; font-weight:600; font-size:11px;
    letter-spacing:0.08em; text-transform:uppercase; color:var(--amber-deep);
    display:block; margin-bottom:6px;
  }
  .rx-label.empty{ color:var(--ink-soft); font-style:normal }

  .scan-section{ margin-top:30px }
  .scan-section .field-label{ margin-bottom:10px }
  .upload-box{
    background:var(--card); border:1.5px dashed rgba(27,42,74,0.25);
    border-radius:12px; padding:18px; text-align:center;
  }
  .upload-box input[type=file]{ font-family:'Inter', sans-serif; font-size:14px }
  #preview{ max-width:100%; margin-top:12px; border-radius:8px; display:none }
  #scanStatus{ font-size:13px; color:var(--ink-soft); margin-top:10px }

  @media (prefers-reduced-motion: reduce){
    * { transition:none !important }
  }
</style>
</head>
<body>
<main>
  <div class="rx-mark">Rx</div>
  <div class="eyebrow">Prescription shorthand, decoded</div>
  <h1>MedSpeak</h1>
  <p class="sub">Type or scan the shorthand exactly as written on the label — get back plain instructions anyone can follow.</p>

  <div class="card">
    <label class="field-label" for="rx">Prescription text</label>
    <div class="row">
      <input type="text" id="rx" placeholder="e.g. 1 tab BID pc" onkeydown="if(event.key==='Enter')go()">
      <button onclick="go()">Decode</button>
    </div>
    <p class="examples">Try <code>1 tab BID pc</code> &middot; <code>PRN q6h</code> &middot; <code>2 cap TID AC PO</code></p>

    <div class="label-wrap">
      <div class="rx-label empty" id="out">
        <span class="tag">Instructions</span>
        Decoded text will appear here.
      </div>
    </div>
  </div>

  <div class="scan-section">
    <label class="field-label">Or scan a photo of the prescription</label>
    <div class="upload-box">
      <input type="file" id="imgInput" accept="image/*" onchange="handleImage(event)">
      <img id="preview">
      <p id="scanStatus"></p>
    </div>
  </div>
</main>

<script>
async function go(){
  const text = document.getElementById('rx').value;
  const out = document.getElementById('out');
  if(!text.trim()){ return; }
  const res = await fetch('/api/decode', {
    method: 'POST',
    headers: {'Content-Type':'application/json'},
    body: JSON.stringify({text: text})
  });
  const data = await res.json();
  out.classList.remove('empty');
  out.innerHTML = '<span class="tag">Instructions</span>' + data.result;
}

function handleImage(event){
  const file = event.target.files[0];
  if (!file) return;
  const preview = document.getElementById('preview');
  preview.src = URL.createObjectURL(file);
  preview.style.display = 'block';
  scanImage(file);
}

async function scanImage(file){
  const status = document.getElementById('scanStatus');
  status.innerText = "Reading text from image...";
  try {
    const result = await Tesseract.recognize(file, 'eng');
    const rawText = result.data.text.trim();
    status.innerText = rawText ? ("Detected: " + rawText) : "No text found — try a clearer photo.";
    if (rawText){
      document.getElementById('rx').value = rawText.replace(/\\n/g, ' ');
      go();
    }
  } catch(e){
    status.innerText = "Scan failed — type it manually instead.";
  }
}
</script>
</body></html>
"""

class Handler(BaseHTTPRequestHandler):
    def _send(self, code, body, ctype="application/json"):
        self.send_response(code)
        self.send_header("Content-Type", ctype)
        self.end_headers()
        self.wfile.write(body.encode())

    def do_GET(self):
        if self.path == "/":
            self._send(200, HTML_PAGE, "text/html")
        else:
            self._send(404, "{}")

    def do_POST(self):
        if self.path == "/api/decode":
            length = int(self.headers.get("Content-Length", 0))
            data = json.loads(self.rfile.read(length) or "{}")
            text = data.get("text", "")
            result = decode(text)
            self._send(200, json.dumps({"result": result}))
        else:
            self._send(404, "{}")

    def log_message(self, *args):
        pass

if __name__ == "__main__":
    print("MedSpeak running at http://localhost:8000")
    ThreadingHTTPServer(("0.0.0.0", 8000), Handler).serve_forever()

Run it with python medspeak.py and open http://localhost:8000.

6. Trying it out

Same decoding examples as before, plus the new scan path:

Input method	Example	Output
Typed	`1 tab BID pc`	Take 1 tablet twice a day after meals
Typed	`PRN q6h`	As needed every 6 hours
Scanned photo of a label reading `2 CAP TID AC PO`	(photo)	Take 2 capsules three times a day before meals by mouth

Wrap-up

The nice thing about doing OCR client-side with Tesseract.js is that no photo of anyone's prescription ever touches the server — recognition happens entirely in the browser tab, and only the recognized text gets sent to /api/decode. That's a meaningful privacy property for a tool handling medical labels, and it came essentially for free by picking a client-side OCR library instead of a server-side one.

Note: OCR accuracy varies with photo quality, lighting, and handwriting — always double-check scanned results against the actual label, and consult your pharmacist for anything ambiguous.

Building a Retry Decorator for Flaky Functions

BlackyDoe — Thu, 23 Jul 2026 16:03:32 +0000

Network calls fail. APIs time out. Databases hiccup. Instead of wrapping every unreliable call in its own manual try/except loop, it's worth writing that logic once as a decorator you can drop on top of any function.

1. The core idea

A decorator wraps a function, catches exceptions, waits, and tries again — up to a configurable number of attempts.

import time
import functools

def retry(times=3, delay=1):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            last_error = None
            for attempt in range(1, times + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_error = e
                    print(f"Attempt {attempt} failed: {e}")
                    time.sleep(delay)
            raise last_error
        return wrapper
    return decorator

@functools.wraps(func) preserves the wrapped function's name and docstring, so debugging tools and introspection still show the original function rather than a generic wrapper.

2. Why the decorator takes arguments

Notice retry isn't the decorator itself — it's a function that returns one. That's what allows @retry(times=3, delay=2) to accept parameters, instead of being locked into one fixed retry count for every use.

@retry(times=3, delay=2)
def fetch_data():
    import random
    if random.random() < 0.7:
        raise ConnectionError("timeout")
    return "success"

Each call to fetch_data() now automatically retries up to 3 times, waiting 2 seconds between attempts, before giving up and re-raising the last error.

3. What happens on final failure

If every attempt fails, the decorator re-raises the last captured exception rather than swallowing it silently:

raise last_error

This matters — a retry wrapper that hides failures after giving up would make debugging much harder. The caller still finds out the operation ultimately failed, just after a few automatic attempts.

4. The full script, start to end

import time
import functools
import random

def retry(times=3, delay=1):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            last_error = None
            for attempt in range(1, times + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_error = e
                    print(f"Attempt {attempt} failed: {e}")
                    time.sleep(delay)
            raise last_error
        return wrapper
    return decorator

@retry(times=3, delay=2)
def fetch_data():
    if random.random() < 0.7:
        raise ConnectionError("timeout")
    return "success"

if __name__ == "__main__":
    print(fetch_data())

5. Trying it out

A typical run might print:

Attempt 1 failed: timeout
Attempt 2 failed: timeout
success

Since fetch_data fails 70% of the time in this example, three attempts usually — but not always — succeed.

Wrap-up

This is the simplest version of a retry pattern: fixed delay, fixed attempt count. Production systems typically want exponential backoff (doubling the delay each attempt) and jitter (a small random offset) to avoid many clients retrying in lockstep and overwhelming a recovering service. But as a foundation, this decorator captures the core idea in about a dozen lines, and it's easy to extend once you need more sophistication.

Building a Zero-Dependency CSV-to-JSON Converter

BlackyDoe — Thu, 23 Jul 2026 15:51:08 +0000

Sometimes you export a spreadsheet and the next tool in your pipeline wants JSON instead. Pulling in pandas for that feels like overkill — Python's standard library already has everything needed. Here's a small converter that does it in a handful of lines, no third-party packages required.

1. Reading the CSV

csv.DictReader turns each row into a dictionary keyed by the header row automatically — no manual header parsing needed.

import csv

def read_csv(csv_path):
    with open(csv_path, newline="", encoding="utf-8") as f:
        reader = csv.DictReader(f)
        return list(reader)

Wrapping the result in list() consumes the whole reader up front, which is fine for small-to-medium files and much simpler to reason about than lazily iterating later.

2. Writing the JSON

import json

def write_json(rows, json_path):
    with open(json_path, "w", encoding="utf-8") as f:
        json.dump(rows, f, indent=2)

indent=2 keeps the output human-readable, which matters if anyone will actually open the file to sanity-check it.

3. Wiring it together

def csv_to_json(csv_path, json_path):
    rows = read_csv(csv_path)
    write_json(rows, json_path)
    return len(rows)

Returning the row count gives a quick sanity check — if you expected 500 contacts and it says 3, something upstream went wrong before you even open the output file.

4. The full script, start to end

import csv
import json

def read_csv(csv_path):
    with open(csv_path, newline="", encoding="utf-8") as f:
        reader = csv.DictReader(f)
        return list(reader)

def write_json(rows, json_path):
    with open(json_path, "w", encoding="utf-8") as f:
        json.dump(rows, f, indent=2)

def csv_to_json(csv_path, json_path):
    rows = read_csv(csv_path)
    write_json(rows, json_path)
    return len(rows)

if __name__ == "__main__":
    count = csv_to_json("contacts.csv", "contacts.json")
    print(f"Converted {count} rows -> contacts.json")

5. Trying it out

Given a contacts.csv like:

name,email,city
Alice,alice@example.com,Austin
Bob,bob@example.com,Denver

Running the script produces:

[
  {
    "name": "Alice",
    "email": "alice@example.com",
    "city": "Austin"
  },
  {
    "name": "Bob",
    "email": "bob@example.com",
    "city": "Denver"
  }
]

Wrap-up

This covers the common case: clean, well-formed CSVs with a single header row. For messier real-world files — inconsistent encodings, embedded commas, multi-line fields — Python's csv module already handles most of that correctly via proper quoting, but very irregular exports may need extra cleanup before conversion. Still, for a quick spreadsheet-to-API pipeline, this is often all you need.

Building a Transparent Password Strength Checker

BlackyDoe — Thu, 23 Jul 2026 15:50:31 +0000

Most password strength meters on signup forms are black boxes — a colored bar shifts from red to green and you have no idea what's actually being measured. So I built a small, transparent version: a scoring function you can read top to bottom and understand exactly why a password got the rating it did.

The goal isn't cryptographic rigor — it's a clear, tweakable scorecard you can drop into a form for live feedback.

1. The scoring rules

Four checks, each worth points: length, uppercase presence, digit presence, and symbol presence. Each failed check also generates a specific tip.

import re

def check_strength(password):
    score = 0
    tips = []

    if len(password) >= 12:
        score += 2
    elif len(password) >= 8:
        score += 1
    else:
        tips.append("Use at least 8 characters")

    if re.search(r"[A-Z]", password):
        score += 1
    else:
        tips.append("Add an uppercase letter")

    if re.search(r"[0-9]", password):
        score += 1
    else:
        tips.append("Add a number")

    if re.search(r"[^A-Za-z0-9]", password):
        score += 1
    else:
        tips.append("Add a symbol")

    return score, tips

Length gets weighted more heavily than the other checks (2 points for 12+ characters vs. 1 point for each other rule), since length is generally the strongest predictor of real-world password strength.

2. Turning the score into a label

A raw number isn't user-friendly, so the score maps to one of six labels.

def strength_label(score):
    levels = ["Very Weak", "Weak", "Okay", "Good", "Strong", "Very Strong"]
    return levels[min(score, len(levels) - 1)]

The min(score, len(levels) - 1) guards against an out-of-range index if the scoring rules ever get extended and start producing higher totals.

3. Putting it together

def evaluate_password(password):
    score, tips = check_strength(password)
    label = strength_label(score)
    return {"score": score, "label": label, "tips": tips}

4. The full script, start to end

import re

def check_strength(password):
    score = 0
    tips = []

    if len(password) >= 12:
        score += 2
    elif len(password) >= 8:
        score += 1
    else:
        tips.append("Use at least 8 characters")

    if re.search(r"[A-Z]", password):
        score += 1
    else:
        tips.append("Add an uppercase letter")

    if re.search(r"[0-9]", password):
        score += 1
    else:
        tips.append("Add a number")

    if re.search(r"[^A-Za-z0-9]", password):
        score += 1
    else:
        tips.append("Add a symbol")

    return score, tips

def strength_label(score):
    levels = ["Very Weak", "Weak", "Okay", "Good", "Strong", "Very Strong"]
    return levels[min(score, len(levels) - 1)]

def evaluate_password(password):
    score, tips = check_strength(password)
    label = strength_label(score)
    return {"score": score, "label": label, "tips": tips}

if __name__ == "__main__":
    for pw in ["abc", "abcdefgh", "Coffee123", "Coffee123!"]:
        result = evaluate_password(pw)
        print(pw, "->", result)

5. Trying it out

Password	Label	Tips
`abc`	Very Weak	Use at least 8 characters, add uppercase, add a number, add a symbol
`abcdefgh`	Weak	Add uppercase, add a number, add a symbol
`Coffee123`	Good	Add a symbol
`Coffee123!`	Very Strong	—

Wrap-up

This isn't a replacement for a real password-strength library like zxcvbn, which models actual attacker behavior (common patterns, dictionary words, keyboard walks). But for a lightweight, dependency-free check with human-readable feedback, a rule-based scorecard like this does the job — and it's easy to extend with your own rules if you want to penalize common passwords or repeated characters.

Note: strength scoring like this estimates resistance to guessing, not resistance to leaked-password reuse — always pair it with breach-check tools like Have I Been Pwned's API for real-world security.

Building MedSpeak: A Tiny Tool That Translates Prescription Shorthand

BlackyDoe — Thu, 23 Jul 2026 15:39:56 +0000

Building MedSpeak: A Tiny Tool That Translates Prescription Shorthand

Ever picked up a prescription and stared at "1 tab BID pc" like it was a secret code? That's because it basically is one. Pharmacy shorthand — abbreviations for frequency, timing, route, and form — makes total sense to clinicians and pharmacists, but leaves most patients guessing.

So I built MedSpeak, a small Python + HTML tool that takes shorthand like 2 cap TID AC PO and turns it into plain English: "Take 2 capsules three times a day before meals by mouth." No frameworks, no database — just a lookup table and a tiny web server.

Here's how it works, broken into pieces you can follow (and tweak) on your own.

1. The lookup tables

The core idea is a handful of dictionaries mapping abbreviation → plain phrase. Frequency codes like bid (twice a day) or qid (four times a day), timing codes like ac (before meals), route codes like po (by mouth) or iv (by IV), and form codes like tab (tablet) or cap (capsule).

FREQUENCY = {
    "qd": "once a day", "od": "once a day",
    "bid": "twice a day",
    "tid": "three times a day",
    "qid": "four times a day",
    "qod": "every other day",
    "hs": "at bedtime",
    "stat": "immediately",
    "prn": "as needed",
    "am": "in the morning", "qam": "every morning",
    "pm": "in the evening", "qpm": "every evening",
}

TIMING = {
    "ac": "before meals",
    "pc": "after meals",
    "cc": "with meals",
}

ROUTE = {
    "po": "by mouth",
    "sl": "under the tongue",
    "iv": "by IV",
    "im": "as an injection into the muscle",
    "sc": "as an injection under the skin",
    "sq": "as an injection under the skin",
    "pr": "rectally",
    "top": "applied to the skin",
}

FORM = {
    "tab": "tablet", "tabs": "tablets",
    "cap": "capsule", "caps": "capsules",
    "ml": "ml",
    "mg": "mg",
    "gtt": "drop", "gtts": "drops",
}

Keeping these as flat dictionaries makes the tool easy to extend — adding a new abbreviation is a one-line change.

2. The decoding logic

The translate() function splits the input into tokens, checks each one against the tables in order, and reassembles a sentence. It also handles numeric doses and the common qXh pattern (like q6h → "every 6 hours").

def translate(text):
    tokens = text.replace(",", " ").split()
    result = []
    for tok in tokens:
        raw = tok.strip(".")
        low = raw.lower()

        if low.isdigit():
            result.append(f"Take {low}")
        elif low in FORM:
            result.append(FORM[low])
        elif low in FREQUENCY:
            result.append(FREQUENCY[low])
        elif low in TIMING:
            result.append(TIMING[low])
        elif low in ROUTE:
            result.append(ROUTE[low])
        elif low.startswith("q") and low.endswith("h") and low[1:-1].isdigit():
            hrs = low[1:-1]
            result.append(f"every {hrs} hours")
        else:
            result.append(raw)

    sentence = " ".join(result)
    return sentence[0].upper() + sentence[1:] if sentence else ""

Anything unrecognized just passes through untouched, so the tool degrades gracefully instead of failing on unfamiliar shorthand.

3. The HTML page

The whole UI is a single templated string: a title, an input box, a "Translate" button, and a "label card" styled to look like an actual prescription sticker. Two placeholders get swapped in on each request — the last thing the user typed, and the translated result.

HTML_PAGE = """
<!DOCTYPE html>
<html><head><meta charset="utf-8">
<title>MedSpeak</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link href="https://fonts.googleapis.com/css2?family=Lora:wght@500;600&family=Inter:wght@400;500;600&family=IBM+Plex+Mono:wght@500;600&display=swap" rel="stylesheet">
<style>
  :root{
    --paper: #E8EDE6;
    --card: #FBFAF6;
    --ink: #1B2A4A;
    --ink-soft: #4A5A72;
    --amber: #C17817;
    --amber-deep: #9C5F10;
    --clay: #B3492B;
  }
  *{box-sizing:border-box}
  body{
    margin:0; padding:32px 16px 60px;
    background:var(--paper);
    background-image:
      radial-gradient(circle at 15% 8%, rgba(193,120,23,0.06), transparent 40%),
      radial-gradient(circle at 85% 90%, rgba(27,42,74,0.05), transparent 40%);
    font-family:'Inter', sans-serif;
    color:var(--ink);
    display:flex; justify-content:center;
  }
  main{width:100%; max-width:560px}

  .eyebrow{
    font-family:'IBM Plex Mono', monospace;
    font-size:12px; letter-spacing:0.12em; text-transform:uppercase;
    color:var(--amber-deep); font-weight:600;
  }
  h1{
    font-family:'Lora', serif; font-weight:600;
    font-size:clamp(28px, 5vw, 36px);
    margin:6px 0 4px; color:var(--ink);
  }
  .sub{ color:var(--ink-soft); font-size:15px; margin:0 0 28px; max-width:44ch; line-height:1.5}

  .rx-mark{
    display:inline-flex; align-items:center; justify-content:center;
    width:40px; height:40px; border-radius:10px;
    background:var(--ink); color:var(--paper);
    font-family:'Lora', serif; font-weight:600; font-size:20px;
    margin-bottom:14px;
  }

  .card{
    background:var(--card); border-radius:14px; padding:22px;
    box-shadow:0 1px 2px rgba(27,42,74,0.06), 0 8px 24px rgba(27,42,74,0.05);
    border:1px solid rgba(27,42,74,0.08);
  }

  label.field-label{
    display:block; font-size:13px; font-weight:600; color:var(--ink-soft);
    margin-bottom:6px;
  }

  input[type=text]{
    width:100%; padding:12px 14px; font-size:16px;
    border-radius:8px; border:1.5px solid rgba(27,42,74,0.18);
    font-family:'IBM Plex Mono', monospace; background:#fff; color:var(--ink);
  }
  input[type=text]:focus{
    outline:3px solid rgba(193,120,23,0.35); outline-offset:1px;
    border-color:var(--amber);
  }

  .row{ display:flex; gap:10px; margin-top:12px }
  .row input{flex:1}

  button{
    padding:12px 20px; font-size:15px; font-weight:600;
    border:none; border-radius:8px; cursor:pointer;
    background:var(--amber); color:#fff;
    font-family:'Inter', sans-serif;
    transition:background .15s ease;
  }
  button:hover{ background:var(--amber-deep) }
  button:focus-visible{ outline:3px solid var(--ink); outline-offset:2px }

  .examples{ font-size:13px; color:var(--ink-soft); margin-top:10px }
  .examples code{
    font-family:'IBM Plex Mono', monospace; background:rgba(27,42,74,0.06);
    padding:2px 6px; border-radius:4px;
  }

  .label-wrap{ margin-top:26px }
  .rx-label{
    position:relative;
    background:#fff;
    border:1.5px solid rgba(27,42,74,0.15);
    border-radius:2px;
    padding:18px 18px 16px;
    font-family:'IBM Plex Mono', monospace;
    font-size:15px; line-height:1.55; color:var(--ink);
    transform:rotate(-0.6deg);
    box-shadow:0 6px 16px rgba(27,42,74,0.10);
  }
  .rx-label::before{
    content:"";
    position:absolute; top:-1px; left:8px; right:8px; height:1px;
    background-image: repeating-linear-gradient(90deg, rgba(27,42,74,0.35) 0 6px, transparent 6px 12px);
  }
  .rx-label .tag{
    font-family:'Inter', sans-serif; font-weight:600; font-size:11px;
    letter-spacing:0.08em; text-transform:uppercase; color:var(--amber-deep);
    display:block; margin-bottom:6px;
  }
  .rx-label.empty{ color:var(--ink-soft); font-style:normal }

  @media (prefers-reduced-motion: reduce){
    * { transition:none !important }
  }
</style>
</head>
<body>
<main>
  <div class="rx-mark">Rx</div>
  <div class="eyebrow">Prescription shorthand, decoded</div>
  <h1>MedSpeak</h1>
  <p class="sub">Type the shorthand exactly as written on the label — get back plain instructions anyone can follow.</p>

  <div class="card">
    <label class="field-label" for="rx">Prescription text</label>
    <form action="/api/translate" method="POST">
      <div class="row">
        <input type="text" id="rx" name="text" placeholder="e.g. 1 tab BID pc" value="__LAST_TEXT__">
        <button type="submit">Translate</button>
      </div>
    </form>
    <p class="examples">Try <code>1 tab BID pc</code> &middot; <code>PRN q6h</code> &middot; <code>2 cap TID AC PO</code></p>

    <div class="label-wrap">
      <div class="rx-label__EMPTY_CLASS__" id="out">
        <span class="tag">Instructions</span>
        __RESULT_TEXT__
      </div>
    </div>
  </div>
</main>
</body></html>
"""

def render_page(last_text="", result_text=None):
    if result_text is None:
        empty_class = " empty"
        result_text = "Translated text will appear here."
    else:
        empty_class = ""
    def esc(s):
        return (s.replace("&", "&amp;").replace("<", "&lt;")
                 .replace(">", "&gt;").replace('"', "&quot;"))
    page = HTML_PAGE
    page = page.replace("__LAST_TEXT__", esc(last_text))
    page = page.replace("__EMPTY_CLASS__", empty_class)
    page = page.replace("__RESULT_TEXT__", esc(result_text))
    return page

4. Serving it as a web page

MedSpeak runs on Python's built-in http.server — no third-party dependencies at all. A GET / returns the page; a POST /api/translate reads the submitted form body, runs it through translate(), and re-renders the page with the result filled in. Only two imports are used in the whole project: http.server and urllib.parse, both from the standard library — nothing to pip install.

from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import unquote_plus

class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path == "/":
            self._send(200, render_page())
        else:
            self._send(404, "Not found")

    def do_POST(self):
        if self.path == "/api/translate":
            length = int(self.headers.get("Content-Length", 0))
            body = self.rfile.read(length).decode()
            params = {}
            for pair in body.split("&"):
                if "=" in pair:
                    k, v = pair.split("=", 1)
                    params[unquote_plus(k)] = unquote_plus(v)
            text = params.get("text", "")
            result = translate(text)
            self._send(200, render_page(last_text=text, result_text=result))
        else:
            self._send(404, "Not found")

    def _send(self, code, body, ctype="text/html"):
        self.send_response(code)
        self.send_header("Content-Type", ctype)
        self.end_headers()
        self.wfile.write(body.encode())

    def log_message(self, *args):
        pass

if __name__ == "__main__":
    print("MedSpeak running at http://localhost:8000")
    ThreadingHTTPServer(("0.0.0.0", 8000), Handler).serve_forever()

5. The full script, start to end

Everything above, combined into one file. Save it as medspeak.py and run python medspeak.py, then open http://localhost:8000:

from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import unquote_plus

FREQUENCY = {
    "qd": "once a day", "od": "once a day",
    "bid": "twice a day",
    "tid": "three times a day",
    "qid": "four times a day",
    "qod": "every other day",
    "hs": "at bedtime",
    "stat": "immediately",
    "prn": "as needed",
    "am": "in the morning", "qam": "every morning",
    "pm": "in the evening", "qpm": "every evening",
}

TIMING = {
    "ac": "before meals",
    "pc": "after meals",
    "cc": "with meals",
}

ROUTE = {
    "po": "by mouth",
    "sl": "under the tongue",
    "iv": "by IV",
    "im": "as an injection into the muscle",
    "sc": "as an injection under the skin",
    "sq": "as an injection under the skin",
    "pr": "rectally",
    "top": "applied to the skin",
}

FORM = {
    "tab": "tablet", "tabs": "tablets",
    "cap": "capsule", "caps": "capsules",
    "ml": "ml",
    "mg": "mg",
    "gtt": "drop", "gtts": "drops",
}

def translate(text):
    tokens = text.replace(",", " ").split()
    result = []
    for tok in tokens:
        raw = tok.strip(".")
        low = raw.lower()

        if low.isdigit():
            result.append(f"Take {low}")
        elif low in FORM:
            result.append(FORM[low])
        elif low in FREQUENCY:
            result.append(FREQUENCY[low])
        elif low in TIMING:
            result.append(TIMING[low])
        elif low in ROUTE:
            result.append(ROUTE[low])
        elif low.startswith("q") and low.endswith("h") and low[1:-1].isdigit():
            hrs = low[1:-1]
            result.append(f"every {hrs} hours")
        else:
            result.append(raw)

    sentence = " ".join(result)
    return sentence[0].upper() + sentence[1:] if sentence else ""

HTML_PAGE = """
<!DOCTYPE html>
<html><head><meta charset="utf-8">
<title>MedSpeak</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link href="https://fonts.googleapis.com/css2?family=Lora:wght@500;600&family=Inter:wght@400;500;600&family=IBM+Plex+Mono:wght@500;600&display=swap" rel="stylesheet">
<style>
  :root{
    --paper: #E8EDE6;
    --card: #FBFAF6;
    --ink: #1B2A4A;
    --ink-soft: #4A5A72;
    --amber: #C17817;
    --amber-deep: #9C5F10;
    --clay: #B3492B;
  }
  *{box-sizing:border-box}
  body{
    margin:0; padding:32px 16px 60px;
    background:var(--paper);
    background-image:
      radial-gradient(circle at 15% 8%, rgba(193,120,23,0.06), transparent 40%),
      radial-gradient(circle at 85% 90%, rgba(27,42,74,0.05), transparent 40%);
    font-family:'Inter', sans-serif;
    color:var(--ink);
    display:flex; justify-content:center;
  }
  main{width:100%; max-width:560px}

  .eyebrow{
    font-family:'IBM Plex Mono', monospace;
    font-size:12px; letter-spacing:0.12em; text-transform:uppercase;
    color:var(--amber-deep); font-weight:600;
  }
  h1{
    font-family:'Lora', serif; font-weight:600;
    font-size:clamp(28px, 5vw, 36px);
    margin:6px 0 4px; color:var(--ink);
  }
  .sub{ color:var(--ink-soft); font-size:15px; margin:0 0 28px; max-width:44ch; line-height:1.5}

  .rx-mark{
    display:inline-flex; align-items:center; justify-content:center;
    width:40px; height:40px; border-radius:10px;
    background:var(--ink); color:var(--paper);
    font-family:'Lora', serif; font-weight:600; font-size:20px;
    margin-bottom:14px;
  }

  .card{
    background:var(--card); border-radius:14px; padding:22px;
    box-shadow:0 1px 2px rgba(27,42,74,0.06), 0 8px 24px rgba(27,42,74,0.05);
    border:1px solid rgba(27,42,74,0.08);
  }

  label.field-label{
    display:block; font-size:13px; font-weight:600; color:var(--ink-soft);
    margin-bottom:6px;
  }

  input[type=text]{
    width:100%; padding:12px 14px; font-size:16px;
    border-radius:8px; border:1.5px solid rgba(27,42,74,0.18);
    font-family:'IBM Plex Mono', monospace; background:#fff; color:var(--ink);
  }
  input[type=text]:focus{
    outline:3px solid rgba(193,120,23,0.35); outline-offset:1px;
    border-color:var(--amber);
  }

  .row{ display:flex; gap:10px; margin-top:12px }
  .row input{flex:1}

  button{
    padding:12px 20px; font-size:15px; font-weight:600;
    border:none; border-radius:8px; cursor:pointer;
    background:var(--amber); color:#fff;
    font-family:'Inter', sans-serif;
    transition:background .15s ease;
  }
  button:hover{ background:var(--amber-deep) }
  button:focus-visible{ outline:3px solid var(--ink); outline-offset:2px }

  .examples{ font-size:13px; color:var(--ink-soft); margin-top:10px }
  .examples code{
    font-family:'IBM Plex Mono', monospace; background:rgba(27,42,74,0.06);
    padding:2px 6px; border-radius:4px;
  }

  .label-wrap{ margin-top:26px }
  .rx-label{
    position:relative;
    background:#fff;
    border:1.5px solid rgba(27,42,74,0.15);
    border-radius:2px;
    padding:18px 18px 16px;
    font-family:'IBM Plex Mono', monospace;
    font-size:15px; line-height:1.55; color:var(--ink);
    transform:rotate(-0.6deg);
    box-shadow:0 6px 16px rgba(27,42,74,0.10);
  }
  .rx-label::before{
    content:"";
    position:absolute; top:-1px; left:8px; right:8px; height:1px;
    background-image: repeating-linear-gradient(90deg, rgba(27,42,74,0.35) 0 6px, transparent 6px 12px);
  }
  .rx-label .tag{
    font-family:'Inter', sans-serif; font-weight:600; font-size:11px;
    letter-spacing:0.08em; text-transform:uppercase; color:var(--amber-deep);
    display:block; margin-bottom:6px;
  }
  .rx-label.empty{ color:var(--ink-soft); font-style:normal }

  @media (prefers-reduced-motion: reduce){
    * { transition:none !important }
  }
</style>
</head>
<body>
<main>
  <div class="rx-mark">Rx</div>
  <div class="eyebrow">Prescription shorthand, decoded</div>
  <h1>MedSpeak</h1>
  <p class="sub">Type the shorthand exactly as written on the label — get back plain instructions anyone can follow.</p>

  <div class="card">
    <label class="field-label" for="rx">Prescription text</label>
    <form action="/api/translate" method="POST">
      <div class="row">
        <input type="text" id="rx" name="text" placeholder="e.g. 1 tab BID pc" value="__LAST_TEXT__">
        <button type="submit">Translate</button>
      </div>
    </form>
    <p class="examples">Try <code>1 tab BID pc</code> &middot; <code>PRN q6h</code> &middot; <code>2 cap TID AC PO</code></p>

    <div class="label-wrap">
      <div class="rx-label__EMPTY_CLASS__" id="out">
        <span class="tag">Instructions</span>
        __RESULT_TEXT__
      </div>
    </div>
  </div>
</main>
</body></html>
"""

def render_page(last_text="", result_text=None):
    if result_text is None:
        empty_class = " empty"
        result_text = "Translated text will appear here."
    else:
        empty_class = ""
    def esc(s):
        return (s.replace("&", "&amp;").replace("<", "&lt;")
                 .replace(">", "&gt;").replace('"', "&quot;"))
    page = HTML_PAGE
    page = page.replace("__LAST_TEXT__", esc(last_text))
    page = page.replace("__EMPTY_CLASS__", empty_class)
    page = page.replace("__RESULT_TEXT__", esc(result_text))
    return page

class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path == "/":
            self._send(200, render_page())
        else:
            self._send(404, "Not found")

    def do_POST(self):
        if self.path == "/api/translate":
            length = int(self.headers.get("Content-Length", 0))
            body = self.rfile.read(length).decode()
            params = {}
            for pair in body.split("&"):
                if "=" in pair:
                    k, v = pair.split("=", 1)
                    params[unquote_plus(k)] = unquote_plus(v)
            text = params.get("text", "")
            result = translate(text)
            self._send(200, render_page(last_text=text, result_text=result))
        else:
            self._send(404, "Not found")

    def _send(self, code, body, ctype="text/html"):
        self.send_response(code)
        self.send_header("Content-Type", ctype)
        self.end_headers()
        self.wfile.write(body.encode())

    def log_message(self, *args):
        pass

if __name__ == "__main__":
    print("MedSpeak running at http://localhost:8000")
    ThreadingHTTPServer(("0.0.0.0", 8000), Handler).serve_forever()

6. Trying it out

A few example inputs and what MedSpeak produces:

Shorthand	Plain English
`1 tab BID pc`	Take 1 tablet twice a day after meals
`PRN q6h`	As needed every 6 hours
`2 cap TID AC PO`	Take 2 capsules three times a day before meals by mouth

Wrap-up

MedSpeak is intentionally minimal — a couple of dictionaries and a tiny server — but it shows how a small, well-organized lookup table can make dense professional shorthand accessible to everyone. It's easy to extend with more abbreviations, and easy to fork into other domains (legal jargon, tech acronyms, whatever shorthand you're tired of decoding by hand).

Note: MedSpeak translates common abbreviation conventions — it's not medical advice and isn't a substitute for asking your pharmacist or doctor about your actual prescription.