DEV Community: SPG Medisafe

Modelling Surgical Instrument Sets as Data: A Dilator Set Example

SPG Medisafe — Wed, 21 Oct 2026 13:05:24 +0000

Surgical instruments are often sold as sets, such as a nephrostomy dilator set with ten or more graduated pieces. If you build a catalogue, an inventory tool or a sterile-processing tracker for a hospital, you quickly face a design question: how do you model a set and its parts so that shortages, substitutions and reorders are easy to handle? Here is a small approach.

Separate the set from its members

A set is a template, and the physical tray in a store is an instance of that template. Keeping them apart makes it easy to see what is missing.

from dataclasses import dataclass, field

@dataclass(frozen=True)
class SetItem:
    code: str
    diameter_fr: int
    qty: int = 1

@dataclass
class SetTemplate:
    name: str
    items: list[SetItem] = field(default_factory=list)

template = SetTemplate(
    name="Sequential dilator set",
    items=[SetItem(f"DIL-{d}", d) for d in range(8, 32, 2)],
)

The diameters above are placeholders. Take the real list from the manufacturer's specification sheet.

Compare a tray against its template

from collections import Counter

def missing_items(template: SetTemplate, found_codes: list[str]) -> list[str]:
    needed = Counter({i.code: i.qty for i in template.items})
    have = Counter(found_codes)
    shortfall = needed - have
    return sorted(shortfall.elements())

A scan of the tray after cleaning produces found_codes, and the function returns exactly which sizes must be replaced before the set can be released.

Track reprocessing cycles

Reusable instruments have a stated service life. Store a counter per physical item, not per set, so that one worn piece can be retired without discarding the rest.

CREATE TABLE instrument (
  serial        TEXT PRIMARY KEY,
  code          TEXT NOT NULL,
  cycles_used   INTEGER NOT NULL DEFAULT 0,
  cycles_limit  INTEGER NOT NULL
);

Why it helps buyers

When shortages are visible by size, purchasing can order the single piece that is missing instead of an entire new set. If you want the buyer's view of these products, including types, diameter ranges and supplier checks, read the full guide: nephrostomy dilator set guide.

This is general software advice and not clinical guidance.

Modelling Medical Device Size Variants as SKUs: A Ureteral Stent Example

SPG Medisafe — Fri, 16 Oct 2026 12:25:24 +0000

Medical device catalogues have a recurring design problem: one product, many size variants. A ureteral stent might come in six diameters, a dozen lengths and three materials, which quickly turns into dozens of SKUs. Here is a simple way to model that cleanly so search, filters and imports stay predictable.

The shape of the data

A stent variant is defined by a few attributes that buyers filter on: diameter in Fr, length in cm and material. Everything else, such as sterility and shelf life, usually belongs to the product, not the variant.

from dataclasses import dataclass
from itertools import product

@dataclass(frozen=True)
class StentVariant:
    diameter_fr: float
    length_cm: int
    material: str

    @property
    def sku(self) -> str:
        d = str(self.diameter_fr).replace('.', '')
        return f"DJ-{d}-{self.length_cm}-{self.material[:3].upper()}"

Generate variants instead of typing them

Typing every combination by hand invites mistakes. Generate the grid and then remove the combinations the manufacturer does not actually make.

diameters = [4.7, 6.0, 7.0]
lengths = [22, 24, 26, 28]
materials = ["polyurethane", "silicone"]

all_variants = [StentVariant(d, l, m) for d, l, m in product(diameters, lengths, materials)]

not_made = {(7.0, 22, "silicone")}
variants = [v for v in all_variants
            if (v.diameter_fr, v.length_cm, v.material) not in not_made]

The values above are placeholders. Use the manufacturer's specification sheet as the source of truth for the real grid.

Store variants in a relational table

CREATE TABLE stent_variant (
  sku           TEXT PRIMARY KEY,
  product_id    INTEGER NOT NULL,
  diameter_fr   NUMERIC(3,1) NOT NULL,
  length_cm     SMALLINT NOT NULL,
  material      TEXT NOT NULL,
  UNIQUE (product_id, diameter_fr, length_cm, material)
);

The unique constraint stops duplicate variants from slipping in during bulk imports.

Make filters friendly

Buyers think in ranges, such as slim adult or paediatric, so expose derived groups in your API instead of forcing every user to type exact numbers.

def size_group(v: StentVariant) -> str:
    if v.diameter_fr < 5:
        return "slim or paediatric"
    if v.diameter_fr <= 6:
        return "standard adult"
    return "large calibre"

Why it is worth the effort

Clean variant data means fewer wrong orders, faster quotes and simpler stock reports. To see how buyers actually compare these sizes, including diameter, length and material, read the full guide: dj stent sizes explained for buyers.

This is general software advice and not clinical guidance.

Validating Medical Device Specs in Python: A Stone Basket Example

SPG Medisafe — Tue, 13 Oct 2026 12:15:19 +0000

If you maintain a product catalogue or ERP feed for medical devices, bad specification data is a quiet source of errors. A basket listed with the wrong length or a missing diameter can end up in a tender or an order. Here is a small, practical approach to validating device specs before they are published.

The problem

A ureteroscopic stone retrieval basket has a handful of attributes that buyers filter on: shaft diameter (Fr), working length (cm), cage style, wire count and sterility. Suppliers send these in spreadsheets with inconsistent units and spellings, such as 1.9F, 1.9 Fr or 1.9 french.

Model the data

from dataclasses import dataclass
from typing import Literal

Cage = Literal["helical", "flat-wire", "tipless", "fixed-tip"]

@dataclass
class BasketSpec:
    sku: str
    shaft_fr: float
    length_cm: int
    cage: Cage
    wires: int
    sterile: bool

Normalise before you validate

import re

def parse_fr(value: str) -> float:
    m = re.search(r"(\d+(?:\.\d+)?)", value)
    if not m:
        raise ValueError(f"No diameter in {value!r}")
    return float(m.group(1))

Add sanity checks

def validate(spec: BasketSpec) -> list[str]:
    errors = []
    if not 1.0 <= spec.shaft_fr <= 4.0:
        errors.append("shaft_fr outside expected range")
    if not 50 <= spec.length_cm <= 150:
        errors.append("length_cm outside expected range")
    if spec.wires < 2:
        errors.append("wires must be 2 or more")
    if not spec.sterile:
        errors.append("sterile flag missing")
    return errors

The ranges are placeholders. Take the real limits from each manufacturer's specification sheet rather than hard-coding assumptions.

Fail loudly in your pipeline

Run the validator in CI or in your import job, and reject the batch if any row returns errors. A report listing the SKU and the failing field is much easier for a catalogue team to fix than a silent bad record.

Why it matters

Buyers compare devices on exactly these fields, so clean data means fewer wrong orders and faster quotes. If you want the buyer's side of the story, including cage designs and quality checks, see the full guide: stone retrieval basket guide for buyers.

Note: this is general software advice and not clinical guidance.

Modelling Medical Device Sizes: Encoding Ureteral Access Sheaths in a Product Catalogue

SPG Medisafe — Fri, 09 Oct 2026 07:30:20 +0000

If you build catalogue, ERP or e-commerce systems for medical device companies, you will meet products whose "size" is not one number. Ureteral access sheaths are a good example.

Two diameters and a length

A sheath is labelled like 12/14 Fr, 45 cm:

12 Fr: inner diameter (the working channel for a scope)
14 Fr: outer diameter (what sits in the patient)
45 cm: working length

French units convert simply: mm = Fr / 3. So 12/14 Fr is roughly 4.0 / 4.7 mm.

A simple data model

Storing the size as a single string makes filtering painful. Split it into fields instead:

{
  "product_type": "ureteral_access_sheath",
  "inner_fr": 12,
  "outer_fr": 14,
  "length_cm": 45,
  "coating": "hydrophilic",
  "sterile": true,
  "single_use": true
}

Now the UI can offer filters such as "inner diameter at least 11 Fr" or "length 35 to 46 cm", and you can validate that outer_fr > inner_fr on import.

Compatibility rules

Real buyers search by the instrument they own. A useful rule is: show sheaths where inner_fr is greater than the scope's outer diameter, so there is space for fluid to drain. Store scope diameters in a separate table and join on that rule rather than hard-coding pairs.

Labels and SKUs

Generate the SKU and the pack label from the fields, not by hand, for example UAS-12-14-45. This keeps printed labels, barcodes and the website in sync and avoids the classic error of a 35 cm product shipped in a 45 cm box.

Import validation

Supplier price lists rarely follow one format. Some write 12/14Fr, others 12-14 F or Fr 12/14. A small parser with a regex such as (\d+(?:\.\d)?)\s*[/-]\s*(\d+(?:\.\d)?) handles most variants. Reject rows where the outer value is not larger than the inner one, and flag lengths outside a sensible range, for example 15 to 70 cm, for manual review instead of importing them silently.

Search and SEO

Buyers search with phrases like "12/14 access sheath 45 cm". Generate product titles from the fields in one consistent pattern, and include both the Fr value and the millimetre conversion in the description. Structured data with additionalProperty for each dimension also helps search engines understand the product.