🗄️ CODSWALLOP

The PDB, summarised: every entry for a protein family, cross-referenced in ninety seconds.

🌐 App

codswallop.mdeller.com

✉️ Contact

marc@marcdeller.com

🐙 GitHub

bellcheddar/CODSWALLOP

Comparative Overview of Domains, Structures, Whole-families, Alignments, Ligands, Lineages, Organisms & PDB entries.

A structural biologist has just been handed a protein family and told to get up to speed. CODSWALLOP does an afternoon's work of manual PDB trawling in ninety seconds: every entry, every construct, every ligand, every crystallisation condition, cross-referenced and interactive.

Why it matters: the RCSB and PDBe landing pages are entry-centric. They answer "what is 4XYZ?" very well, and nobody answers the question a working structural biologist actually asks, which is "what do the 87 structures of this family collectively tell me, and what should I do differently?". CODSWALLOP is family-centric: it treats the family as the unit of analysis, so the answer to "which construct crystallises best" or "which residues has nobody ever put in a construct" is one glance rather than an afternoon of tab-juggling. It is useful for: starting a new target, designing a construct, choosing which deposited structure to trust, planning a crystallisation screen, and writing the structural-biology section of a grant.

Live at codswallop.mdeller.com.

🧭 What makes it different

#	Differentiator	Why it matters	Phase
1	Construct diffing	Aligns every deposited SEQRES against the UniProt canonical to expose tags, fusion partners, truncations, surface-entropy-reduction and thermostabilising mutations. This is what actually gets a crystal, and it is buried in mmCIF nobody reads	2
2	Global cross-filtering	One selection state shared by every panel. Click a ligand and the map, the entry list, the crystallisation scatter and the coverage plot all filter together	1
3	Crystallisation intelligence	Parses `_exptl_crystal_grow` across the whole family into structured conditions, so you can see what actually worked. Feeds the Top96 crystallisation predictor	3
4	Coverage census	Which residues has nobody ever seen? A family-wide map answering a construct-design question in one glance	1 (constructs), 2 (density)
5	Interaction fingerprints	PLIP run family-wide, so binding-site contacts are comparable across entries rather than one-off	3

✨ Features (phases 1 to 3 live, phase 4 landing)

Ask for anything. A PDB ID, a PDB entity id, a UniProt accession, a gene name, a Pfam or InterPro accession, a raw sequence (FASTA or bare), or just what the protein is called. Anything genuinely ambiguous returns a disambiguation card rather than a guess: 4HHB asks whether you meant the alpha or beta globin, LYZ asks which of twelve organisms.
One definition of a family. Whatever you type is resolved to a seed sequence, and membership is every PDB polymer entity above a percent-identity threshold to that seed. Every member therefore carries a real identity number to the same reference, so the threshold slider means something exact rather than "whatever the annotation happened to say".
The drawer. An archival shell: a divider rail carrying all ten sections from day one, a family header with a rubber-stamped FILED mark, a stat strip, and an index card that flips out from any entry anywhere without ever losing the family context.
The constellation. Every entry as a node. Once the family has an embedding, position is classical MDS of the pairwise TM-score matrix, so distance on the map is structural distance and the 0.5 contour is the conventional same-fold boundary; until then it falls back to a clearly-labelled identity layout. Node size is 1/resolution, colour is method, an amber halo means ligand-bound. Labels name the clusters the matrix falls into at the same cut the Structures heatmap uses. A ringed node holds several entries that share a construct and opens on click; a hollow node has a position inherited rather than measured; a brass chevron means the structure lies off the end of the scale and has been pinned to the edge.
Cross-highlight. Hovering any row in the entry list pulses that entry's node brass in the map, and hovering a node highlights its row. One state, two representations, and every panel added in later phases binds to the same shared selection state.
Family definition controls. Percent-identity slider, method chips, and include/exclude toggles for orthologues and for chimeras and fusion constructs. All of it filters client-side and instantly: the family is assembled once at the lowest threshold and every control re-filters the same cached set.
Construct coverage census. How many of the family's constructs contain each residue of the seed, as a depth profile. On lysozyme it finds residues 1 to 18 covered by 66 of 1,686 constructs, which is the signal peptide that is cleaved and never present in the mature protein. On p53 it finds residues 361 to 393 in 10 of 267.
Full table view. Sortable, filterable, column-toggleable, with CSV, JSON and BibTeX export. The BibTeX is deduplicated to one record per paper with the PDB IDs collected in a note, which is the tedious part of assembling a family bibliography by hand.
Provenance: what it is called, and who did the work. Every spelling the family is deposited under, reconciled against UniProt's recommended, alternative, short and gene names, plus the reverse direction that actually breaks a literature search: within hen lysozyme's own family, "Lysozyme C" is the deposited description of seven different accessions. Beside it, the depositing groups: last author as the group's proxy (labelled as the convention it is), counted per entry rather than per paper, with a deposition timeline. 380 groups over 1975 to 2026 for lysozyme, the largest holding 8.3 % of it.
Conservation on the surface. ConSurf-style colouring of the loaded structure by family-wide conservation, banded on the family's own quintiles because a family is similar sequences by construction and a fixed scale never uses its variable end. The seed-to-structure frame is scored on residue identity rather than assumed, and refused below 60 % agreement, so a construct with an N-terminal tag is not frame-shifted into a plausible-looking lie.
A JSON API other projects can build against. /api/v1/family/<slug> is a few kilobytes with field names that are a promise and a schema_version to break if one has to change meaning, rather than the front end's own multi-megabyte payload.
Dark by default, light on request. A lamp-lit archive theme that honours prefers-color-scheme and respects prefers-reduced-motion, self-hosted type, and no third-party request on any page load.

🔬 Worked example: a fold nobody searched for

Search 1AKI, hen egg-white lysozyme. It is the most-solved protein in the archive: 1,687 entries, 281 distinct constructs, 26 organisms, and essentially all of it is the same fold solved again. The embedding says so, putting 1,686 of the 1,688 entities in one cloud.

Two are not in it.

They are 9J0L and 9J0M, cryo-EM structures of hen lysozyme amyloid fibrils, and they sit at the far edge with a brass chevron because they are off the end of the scale entirely.

	9J0L and 9J0M
Identity to the seed	100% (identical sequence, and the same construct as each other)
TM-score to the other 76 representatives	min 0.15, median 0.18, max 0.20
Pairs above the 0.5 same-fold line	0 of 76
Method	cryo-EM at 2.29 Å and 3.21 Å

Same protein, same sequence, a completely different fold: native lysozyme refolded into a cross-β fibril. No sequence-based view of this family can find them, because there is nothing in the sequence to find. They are 100% identical to the seed, so an identity slider puts them at the top of the list along with everything else, and the identity layout the map falls back to places them in the middle of the crowd. Only a structural distance separates them, and only a family-centric one makes it obvious that it is two entries out of 1,688 rather than a general property of lysozyme.

What the map is not

Two limits worth stating, because a scatter plot of points looks like a measurement whatever produced it.

It is a shadow, not the thing. The map is two dimensions of an object that has as many as the family has representatives. Across the 70 built families the first two principal coordinates carry a median of 65% of the positive eigenvalue mass, and as little as 33% (the beta-2 adrenergic receptor, tau, insulin, calmodulin). Two structures drawn close together are close in the projection; on a low-variance family they may be further apart than they look. The heatmap in the Structures panel is the higher-fidelity view of the same matrix, which is why both exist.

1 − TM is not a Euclidean distance, so the Gram matrix has negative eigenvalues: a median of 19% of the positive mass, up to 49%. They are clamped to zero rather than the build failing, which is the standard treatment and is honest as far as it goes, but it means the embedding is an approximation of a geometry that does not strictly exist. Reading distance qualitatively (near, far, off on its own) is safe. Reading it as a metric is not, and there is nothing on the panel to stop you: use the TM-score matrix itself for anything quantitative.

This is also why the panel is fitted the way it is. Those two points sit at x = -1.0 while every other representative spans -0.036 to +0.046, so fitting the panel to the furthest point put the entire native family inside 5.4% of its width: a map of one curiosity and a smudge. The fit uses a high quantile with headroom instead, and pins anything beyond it to the rim with its true distance in the tooltip, so the outlier stays visible and stays findable without costing the other 1,686 structures their map.

🧱 Stack

Layer	Choice	Note
Backend	Python 3.12, Flask 3.1, gunicorn 26	No compiled toolchain needed on the droplet in phase 1
Cache	SQLite (WAL)	Raw API responses plus assembled families, both with a one-week TTL
Front end	Vanilla JS, hand-rolled SVG	The map needs direct control of individual nodes for the cross-highlight pulse
Tables	Tabulator 6.3.1	Vendored, skinned to the theme tokens
Type	Archivo, Inter, JetBrains Mono	Self-hosted woff2, latin and latin-ext only, 244 kB total
Serving	nginx, certbot	Same droplet pattern as AlphaFraud

📡 Data sources

All public, none require a key. Please cite them, not this tool, when the data does the work.

Source	Endpoint	Used for
RCSB Search API v2	`search.rcsb.org/rcsbsearch/v2/query`	Family resolution: sequence (mmseqs2), UniProt accession, Pfam/InterPro annotation, full text
RCSB Data API	`data.rcsb.org/graphql`	Batched entry, polymer entity, assembly and chem_comp metadata
UniProt REST	`rest.uniprot.org/`	Canonical sequence, protein name, organism, gene names
InterPro API	`ebi.ac.uk/interpro/api/`	Pfam and InterPro accession names and types

Phases 2 to 4 add the RCSB 1D Coordinates, Alignment and file services, the PDBe REST and Graph APIs, EMDB and the AlphaFold DB.

🧪 Tests

./.venv/bin/pip install pytest
./.venv/bin/python -m pytest

183 tests, none of which touch the network. They are written against the bugs that actually shipped rather than for coverage: a fusion partner being shredded by the aligner, a chimera diffed against the wrong reference, Bis-Tris being tallied as Tris, a saturating "never" statistic, a cached None being refetched forever, a beacon that no page requested, a family outvoting its own subject, a disulphide bond expanded into 122 of them, a decorative spiral that read as structure, a cluster labeller whose preferred input was empty on every real request, an offset applied twice so that contacts landed on residues the protein does not have, and a gene search that answered VEGFR with twelve fruit flies.

🔧 Installation

git clone https://github.com/bellcheddar/CODSWALLOP.git
cd CODSWALLOP
python3 -m venv .venv
./.venv/bin/pip install -r requirements.txt
./.venv/bin/python CODSWALLOP.py init

🚀 Usage

# Run the development server (defaults to 127.0.0.1:8006)
./.venv/bin/python CODSWALLOP.py serve

# Assemble a family from the shell, without a browser
./.venv/bin/python CODSWALLOP.py build P00918
./.venv/bin/python CODSWALLOP.py build "TEM-1 beta-lactamase"
./.venv/bin/python CODSWALLOP.py build PF00062 --refresh

# Cache housekeeping
./.venv/bin/python CODSWALLOP.py stats
./.venv/bin/python CODSWALLOP.py purge

Command	Does
`init`	Create the cache database and apply any column migrations
`serve`	Run the development server (`--bind`, `--debug`)
`build <query>`	Assemble a family and print a summary. Exits 2 with a candidate list if the query is ambiguous
`stats`	Cache statistics: families, entries, entities, cached responses, database size
`purge`	Drop expired cache entries

Routes

Route	Does
`/`	The closed drawer: one search field
`/lookup?q=`	Resolve the input, then redirect to the family or ask which one you meant
`/f/<slug>`	The family. Paints complete if cached, paints its filing state and fetches if not
`/f/<slug>/dossier`	A self-contained family report: one file, no fetches, prints to PDF
`/api/family/<slug>`	Assemble (or serve) a family as JSON. The front end's own payload, not a contract
`/api/v1/families`	What this instance has filed. The entry point for another program
`/api/v1/family/<slug>`	The stable summary. A few kilobytes, versioned schema, CORS open. Never assembles on demand
`/api/stats`	Cache statistics, and the per-app hit beacon for the mdeller.com launcher
`/healthz`	Liveness

🛠️ Configuration

Copy .env.example to .env. Everything has a sensible default in codswallop/config.py.

Variable	Default	Does
`DROPLET_SSH`		SSH destination for `deploy/deploy.sh`
`DROPLET_PATH`	`/opt/codswallop`	Where the code lives on the droplet
`SERVER_NAME`	`codswallop.mdeller.com`	Hostname certbot issues a certificate for
`BIND_ADDR`	`127.0.0.1:8006`	Address gunicorn binds to (8000 to 8005 are taken by the sibling apps)
`CACHE_TTL_HOURS`	`168`	How long a cached API response stays fresh
`FAMILY_TTL_HOURS`	`168`	How long an assembled family stays fresh
`MAX_FAMILY_ENTITIES`	`2500`	Cap on entities pulled into one family

The two TTLs default to a week because the PDB releases weekly: a family cannot gain a member mid-week.

📊 Performance

Measured on carbonic anhydrase II (P00918), 1,490 entries, and lysozyme (P00698), 1,686 entries.

Path	Cost
Cold family assembly	7 to 12 s (one sequence search plus 30 batched GraphQL calls)
Warm family, served from SQLite	0.07 s
Assembled family payload	~1.7 MB JSON, ~240 kB gzipped

The payload is deduplicated before it goes over the wire: sequences, primary citations, chemical components and domain annotations all move to family-level lookup tables, because a family is mostly the same construct solved again. Carbonic anhydrase II has 1,490 entities and 232 distinct sequences. Doing this took the page from 6.3 MB to 1.8 MB.

🎨 Theme tokens

Anything physical is brass (drawer front, dividers, plate, pins, stamps); all data is cool. That rule is what holds the theme together.

Token	Dark	Light	Role
`--bg`	`#131924`	`#EDE7DC`	Room
`--bg-2`	`#182031`	`#E4DCCC`	Drawer interior, rail
`--sky`	`#0F1522`	`#F4F1E9`	Constellation field
`--surface`	`#1F2938`	`#FCFAF5`	Cards, panels
`--surface-2`	`#273346`	`#F1ECE0`	Raised, panel headers
`--line`	`#2E3A4E`	`#D3C7B0`	Borders
`--text`	`#E4EAF6`	`#1D2430`	Type
`--dim`	`#93A2BC`	`#55627A`	Secondary type
`--mute`	`#65748E`	`#7C8AA3`	Tertiary type
`--brass`	`#C9A063`	`#8A6D40`	Anything physical
`--brass-dk`	`#8A6D40`	`#6B5330`	Anything physical, shaded
`--on-brass`	`#1A1408`	`#FDF8EE`	Ink sitting on brass
`--accent`	`#5B8CFF`	`#1F5FD8`	Brand blue
`--cyan`	`#4FD1E3`	`#0F8FA6`	X-ray
`--amber`	`#F5B93F`	`#B47908`	Cryo-EM, ligand halo
`--violet`	`#9B7BE8`	`#6B47C4`	NMR
`--oxide`	`#E0685C`	`#B8382C`	FILED stamp, warnings, disorder flags
`--mint`	`#43C79F`	`#1B8763`	Neutron, pass states

🌐 Deployment

Mirrors the AlphaFraud pattern exactly.

bash deploy/deploy.sh                                    # from your Mac, after the first provision
sudo SERVER_NAME=codswallop.mdeller.com bash /opt/codswallop/deploy/provision.sh   # once, on the droplet

provision.sh is idempotent: system packages, service user, venv, systemd unit, nginx site, Let's Encrypt certificate, and the HTTP/2 patch that certbot does not apply on nginx 1.24.

The droplet builds every artefact itself. There is no second machine and nothing to push: deploy/worker.sh drains the request queue on a fifteen-minute timer, one family at a time, niced so a reader waiting on a page always wins. Compute dependencies are in requirements-compute.txt and install as prebuilt wheels, so the box needs no compiler.

systemctl status codswallop-worker.timer        # is it armed
systemctl start codswallop-worker.service       # force a pass now
tail -f /var/log/codswallop-worker.log          # what it is doing

✅ To Do

Roadmap for CODSWALLOP, in dependency order: each phase is independently shippable, and the divider rail carries every phase's section from day one so navigation never needs rebuilding. Suggestions welcome.

Phase 1: spine (shipped)

Phase 2: sequence, construct and domain intelligence

Fetch the UniProt canonical and every deposited SEQRES. Plus UniProt active and binding sites, used only to describe a mutation ("at an annotated active site"), never to claim what it did
Family alignment with per-column conservation and a sequence logo. A star alignment against the seed rather than a progressive MSA, so a column here is the same column as in the coverage census and the domain ribbon, and no external binary is needed on the droplet. Conservation is normalised Shannon entropy weighted by how many entities used each construct. It also produces the list this panel exists for: positions people deliberately mutate, where the wild type still dominates but a real minority carries something else. On p53 the top of that list is M133L, V203A, N239Y and N268D, which together are the thermostabilising superstable quadruple mutant, alongside the Y220C druggable hotspot; on carbonic anhydrase II it is the active-site pocket variants
Construct diff engine. The flagship, and it works: Align every SEQRES to the canonical and classify: N- and C-terminal expression tags (His6/8/10, Strep-II, FLAG, HA, Myc, Avi), cleavage sites and scar residues (TEV, 3C/PreScission, thrombin, SUMO, enterokinase), fusion partners (MBP, GST, SUMO, Trx, T4 lysozyme, BRIL, rubredoxin, PGS, GFP), truncations and internal loop deletions, point mutations sub-classified as catalytic, thermostabilising, surface entropy reduction or disulphide engineering, and non-canonical residues including SeMet
Replaced the phase 1 fusion heuristic, which was wrong on every case it flagged for carbonic anhydrase II: all four were Schistosoma CA, a genuinely larger protein with a His6 tag, called a fusion only because it was measured against the human seed rather than its own reference
Construct table. One row per unique construct, most-used first, with the entries that used it and their best resolution. On p53 the top row is residues 94-312 carrying M133L/V203A/Y220C at 1.24 Å, and R273H, R249S and R282W each get their best structure: "which construct crystallises best" answered directly
Domain and fold annotation. CATH, SCOP2B and ECOD per chain from the RCSB instance features, aggregated to a consensus with median boundaries and a chain count, drawn as an architecture ribbon. A domain must appear on at least 2 chains (or 1 % of them) to be reported: without that the list filled with domains belonging to other proteins in the complexes, and p53 picked up "Green fluorescent protein" and "Annexin"
Density coverage census. UNOBSERVED_RESIDUE_XYZ per chain, mapped through each member's own alignment offset onto seed coordinates, drawn as a second curve against the construct curve. "Resolved in no construct at all" turned out to be as useless a bar as the binary union (0 % for p53), so the reported figure is the ratio: residues resolved in under a quarter of the constructs that contained them. p53 reads 20.6 %, and names 361-393, 62-90 and 294-312; spike's 1152-1271 is resolved in 4 %; carbonic anhydrase II is 0.8 %
Cross-species orthologue matrix. Organisms by entry count, with best resolution, holo count and the fraction of the seed each one's constructs cover
Bound the construct table to the shared selection state. Hovering a construct dims every node on the map that does not use it, and clicking opens the best entry that did, so a reader lands on a real structure rather than an abstraction

Phase 3: structure, chemistry and interactions

Mol* viewer embedded, single entry. From the index card and from a Structures panel with an entry picker that follows the current filters. Loaded on demand, because Mol* is 5 MB, larger than the whole rest of the page including a 1,500-entry family payload: somebody who came for the construct table should not pay for a renderer they never open. It reads structures straight from the RCSB, so this needs no downloads, no storage and no toolchain on the server, which is what let it ship separately from the pipeline work below. Viewport colour follows the theme toggle
Family superposition, and an AlphaFold overlay with pLDDT colouring. The transforms fall out of the same TM-align run that builds the matrix. The reference is the representative most similar to everything else among the seed's own structures, not the best-resolution one: superposing onto an outlier makes every other structure look wrong, and it is forced into the loaded set because every transform maps onto its frame. Restricting it to the seed is not fussiness. A family is assembled at 30 % identity, so an ABL1 search legitimately returns most of the tyrosine kinases, and the most central structure of that set is an EGFR entry: the page superposed ABL1's family onto a different protein, with nothing on it saying so. The AlphaFold model is superposed, onto the same reference as everything else: the alignment is the same TM-align call, done in the pipeline where TM-align lives rather than in a browser that cannot do it, and the panel reports the TM-score so an overlay of something that does not actually superpose is visible as such. Its URL comes from the AFDB API rather than being constructed: this was written against -model_v4.cif and the DB already serves v6. The accession it fetches is the family's seed, never the accession the most members carry, which is a popularity contest the subject frequently loses: ABL1 and JAK1 both fetched EGFR's model, and every A2A receptor structure carries a BRIL fusion, so A2A fetched the model of E. coli cytochrome b562. Both rendered as a confident superposition of the wrong protein at a TM-score that looked merely poor rather than meaningless.
Pairwise TM-score matrix, and the embedding it produces. The placeholder layout is retired for any family that has one: node positions are classical MDS of the 1 − TM distance matrix, so distance on the map is structural distance and the 0.5 contour is the conventional same-fold boundary. Computed on a workstation, never on the droplet (CODSWALLOP.py embed, then deploy/push_embeddings.sh): it downloads mmCIF files and does real numerical work, and the box has two cores shared with eight apps. tmtools and biotite are in requirements-dev.txt only, and the app reads a JSON artefact through a reader that imports nothing beyond the standard library. (numpy is on the droplet regardless, as a biopython dependency: it is the mmCIF parsing and TM-align that stay off it.) One representative per distinct construct rather than per entry, capped, because superposing two crystal forms of an identical construct measures crystallography rather than biology. Half the cap is reserved for constructs of the protein that was actually searched for, topped up only where ranking by usage would leave it under-represented, so a family whose seed is dominant keeps exactly the nodes it had. Without the reservation an ABL1 search put 2 of its 80 nodes on ABL1, and both were its 63-residue SH3 domain: the map, the reference and the AlphaFold model were all EGFR's. It is now 40 of 80 at a median length of 270, which is the kinase domain (Superseded below: the workstation-only rule fell to per-chain fetching, and the droplet computes this itself now. requirements-compute.txt, not requirements-dev.txt.)
The matrix as a clustered heatmap, with its clusters as filters. Average linkage in the browser, so the cut height is a live control: dragging it is the only way to tell whether a grouping is real or an artefact of where the line sits. Drawn on a canvas, because a 260-representative family is 67,600 cells. The default cut is 0.18, not the conventional 0.5 same-fold line, which returns one cluster for almost any family because every member of a family is the same fold by construction. Picking a cluster narrows the map, the entry list, the table and every other panel through the shared selection state.
Ligand panel. CCD ID, formula, SMILES, occurrence count and best resolution achieved, with a per-component classification into ligand, cofactor, lipid/detergent, ion, buffer, cryoprotectant or solvent. This retires the Phase 1 exclusion list: "ligand-bound" now means a ligand or a cofactor, which took carbonic anhydrase II from 1,208 entities to 1,096 and the receptor from 409 to 395. Each component carries the RCSB's own 2D depiction, fetched lazily because a family can hold hundreds. Whether a metal is structural or catalytic is a property of the protein and not of the component, so this began by filing carbonic anhydrase's catalytic zinc as an ion and saying so on the panel. It is now resolved with evidence rather than by declaring it unresolvable: a metal is promoted to cofactor when the interaction data shows it coordinated by at least 3 residues that are conserved above 0.90, across at least 5 entries, and the promotion states which residues did it. The entry threshold is doing real work, since a single mercury on one entry qualified on every other test
PLIP family-wide. A hot-residue ranking with each residue's conservation beside it, and a ligand-by-residue fingerprint heatmap, in seed coordinates so a hot residue is the same residue as in the conservation track and the domain ribbon. Workstation only, like the embedding. The conversion reuses Marc's cif2plip.py verbatim (vendored to pipeline/) for its pdb_tidy CONECT serial-gap fix; only the PLIP invocation differs, asking for XML rather than the PyMOL session and images a web page cannot use. Validated on carbonic anhydrase II: 890 contacts over 40 entries with no conversion failures, and the top residues come out as His96, Thr199, Thr200, Leu198, His94 and His119, which is the zinc triad and the gatekeeper threonines, found with no prior knowledge of the enzyme anywhere in the pipeline.
Crystallisation panel. _exptl_crystal_grow.pdbx_details is free text a depositor typed, so this is a parser, not a field read: 17 precipitant patterns, 15 buffers with their working pH ranges, 14 additives and 9 setup methods, each carrying the best resolution anyone achieved with it. On the beta-2 adrenergic receptor it finds lipidic cubic phase in 79 of 120 conditions with monoolein and cholesterol as the top additives, which is exactly how that receptor is crystallised. CSV export for TopPDBLX
Quality and validation panel. Clashscore, RSRZ, Ramachandran and rotamer outliers, R-free minus R-work gap, data completeness and structure-factor availability, as a traffic light against the wwPDB report's own thresholds, worst first, with the family's medians for context. The figures live in pdbx_vrpt_summary_geometry and pdbx_vrpt_summary_diffraction; pdbx_vrpt_summary itself holds almost nothing

Phase 4: topology, export and polish

Backlog (deliberately outside the four phases)

📚 Citing the data

CODSWALLOP is a lens over other people's archives. If the data does the work in your paper, cite them:

RCSB PDB: Burley, S.K. et al. Nucleic Acids Res. (2023) 10.1093/nar/gkac1077
PDBe: Armstrong, D.R. et al. Nucleic Acids Res. (2020) 10.1093/nar/gkz990
UniProt: The UniProt Consortium. Nucleic Acids Res. (2023) 10.1093/nar/gkac1052
InterPro: Paysan-Lafosse, T. et al. Nucleic Acids Res. (2023) 10.1093/nar/gkac993

📄 Licence

MIT. See LICENSE.

👤 Author

Marc C. Deller, D.Phil.
Structural biologist & drug discovery scientist

🌐

marcdeller.com

✉️

marc@marcdeller.com

🐙

github.com/bellcheddar/CODSWALLOP

Navigation Menu

Repository files navigation

🗄️ CODSWALLOP

🧭 What makes it different

✨ Features (phases 1 to 3 live, phase 4 landing)

🔬 Worked example: a fold nobody searched for

What the map is not

🧱 Stack

📡 Data sources

🧪 Tests

🔧 Installation

🚀 Usage

Routes

🛠️ Configuration

📊 Performance

🎨 Theme tokens

🌐 Deployment

✅ To Do

Phase 1: spine (shipped)

Phase 2: sequence, construct and domain intelligence

Phase 3: structure, chemistry and interactions

Phase 4: topology, export and polish

Backlog (deliberately outside the four phases)

📚 Citing the data

📄 Licence

👤 Author

About

Releases

Packages

Contributors

Languages

Name		Name	Last commit message	Last commit date
codswallop		codswallop
deploy		deploy
docs/img		docs/img
pipeline		pipeline
tests		tests
.env.example		.env.example
.gitignore		.gitignore
CODSWALLOP.py		CODSWALLOP.py
CODSWALLOP_BUILD_PLAN_v2.md		CODSWALLOP_BUILD_PLAN_v2.md
LICENSE		LICENSE
NEXT.md		NEXT.md
README.md		README.md
pytest.ini		pytest.ini
readme_meta.json		readme_meta.json
requirements-compute.txt		requirements-compute.txt
requirements-dev.txt		requirements-dev.txt
requirements.txt		requirements.txt
wsgi.py		wsgi.py

Latest commit

History

Folders and files

Repository files navigation

🗄️ CODSWALLOP

🧭 What makes it different

✨ Features (phases 1 to 3 live, phase 4 landing)

🔬 Worked example: a fold nobody searched for

What the map is not

🧱 Stack

📡 Data sources

🧪 Tests

🔧 Installation

🚀 Usage

Routes

🛠️ Configuration

📊 Performance

🎨 Theme tokens

🌐 Deployment

✅ To Do

Phase 1: spine (shipped)

Phase 2: sequence, construct and domain intelligence

Phase 3: structure, chemistry and interactions

Phase 4: topology, export and polish

Backlog (deliberately outside the four phases)

📚 Citing the data

📄 Licence

👤 Author

About

Topics

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages