核对分子式与计算性质

from pathlib import Path
import base64, gzip, hashlib, json, platform
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from IPython.display import display, HTML
import re
from IPython.display import display as _display
def display(value):
    if isinstance(value,pd.DataFrame):
        table=value.to_html(max_rows=12,escape=True)
        style="<style>.vibeit-readable-table{max-width:100%;overflow-x:auto}.vibeit-readable-table table{width:max-content;max-width:none;border-collapse:collapse}.vibeit-readable-table td,.vibeit-readable-table th{white-space:nowrap!important;word-break:normal!important;overflow-wrap:normal!important}</style>"
        return _display(HTML(style+'<div class="vibeit-readable-table">'+table+'</div>'))
    return _display(value)
RECIPE_ID='ch01-molecular-formulas'
OUTPUT_DIR=Path.cwd()/"results"/RECIPE_ID
plt.rcParams.update({"figure.dpi":120,"font.size":10,"axes.spines.top":False,"axes.spines.right":False,
                      "axes.prop_cycle":plt.cycler(color=["#18785f","#416aa6","#bc6541","#9974a5"])})
print("Python:",platform.python_version(),"; NumPy:",np.__version__,"; Pandas:",pd.__version__)
print("Working folder:",Path.cwd())
print("Core data mode: embedded snapshot; no network requests")

Python: 3.13.13 ; NumPy: 2.5.3 ; Pandas: 3.0.6
Working folder: /Users/zhiluo/Developer/vibeit-cookbook/cookbook/downloads
Core data mode: embedded snapshot; no network requests

def load_snapshot(recipe_id, expected_sha256, snapshot_key):
    """Read embedded data from this notebook, including a renamed copy."""
    for path in sorted(Path.cwd().glob("*.ipynb")):
        try:
            notebook = json.loads(path.read_text(encoding="utf-8"))
            metadata = notebook.get("metadata", {}).get("vibeit_cookbook", {})
            blob = metadata.get("snapshots", {}).get(snapshot_key)
            if metadata.get("recipe_id") != recipe_id or not blob:
                continue
            if blob.get("sha256") != expected_sha256:
                continue
            raw = gzip.decompress(base64.b64decode(blob["gzip_base64"], validate=True))
            if hashlib.sha256(raw).hexdigest() != expected_sha256:
                raise ValueError("Embedded snapshot checksum mismatch: " + snapshot_key)
            return json.loads(raw)
        except (OSError, json.JSONDecodeError):
            continue
    raise FileNotFoundError(
        "Save/open the complete .ipynb in the active working folder. "
        "The embedded snapshot could not be located for " + recipe_id)

SNAPSHOT_HASHES={'molecules': '780c5f98bb3b7261465f8330d4b31589d4224cdf21f916b4a1788f11bcc00aac'}
def snapshot(key):
    return load_snapshot(RECIPE_ID,SNAPSHOT_HASHES[key],key)
print("Embedded snapshots:",list(SNAPSHOT_HASHES))

Embedded snapshots: ['molecules']

def parse_simple_formula(formula):
    """Parse plain elemental formulas; refuse isotopes, groups and charge notation."""
    tokens=re.findall(r'([A-Z][a-z]?)(\d*)',formula)
    if not tokens or ''.join(element+count for element,count in tokens)!=formula:
        raise ValueError('This teaching parser accepts plain elemental formulas only')
    counts={}
    for element,text in tokens:
        count=int(text) if text else 1
        if count<1:raise ValueError('Element counts must be positive')
        counts[element]=counts.get(element,0)+count
    return counts

print("Method ready: parse_simple_formula")

Method ready: parse_simple_formula

molecules=snapshot("molecules")
properties=pd.DataFrame(molecules["properties"]).set_index("CID")
assert len(properties)==8 and properties.index.is_unique
display(properties[["name","MolecularFormula","MolecularWeight","TPSA","Charge"]])
atomic_weights={"H":1.008,"C":12.011,"N":14.007,"O":15.999}
counts={int(cid):parse_simple_formula(row.MolecularFormula) for cid,row in properties.iterrows()}
assert all(set(count)<=set(atomic_weights) for count in counts.values())

calculated=np.array([sum(atomic_weights[element]*count for element,count in counts[int(cid)].items()) for cid in properties.index])
comparison=properties[["name","MolecularWeight"]].copy();comparison["reconstructed_g_per_mol"]=calculated
comparison["difference_g_per_mol"]=calculated-properties.MolecularWeight
fig,ax=plt.subplots(figsize=(8,4));ax.barh(properties.name,properties.MolecularWeight,label="PubChem")
ax.plot(calculated,np.arange(8),"kx",label="Rounded atomic-weight reconstruction")
ax.set(xlabel="Molar mass (g/mol)",title="Formula-based reconstruction of calculated source masses");ax.legend();plt.tight_layout();plt.show()

fraction=pd.DataFrame({element:[atomic_weights[element]*counts[int(cid)].get(element,0)/calculated[j] for j,cid in enumerate(properties.index)] for element in atomic_weights},index=properties.name)
fig,ax=plt.subplots(figsize=(9,4));(100*fraction).plot.bar(stacked=True,ax=ax)
ax.set(ylabel="Elemental mass (%)",xlabel="Declared compound",title="Mass fractions under the stated atomic-weight convention");plt.xticks(rotation=25,ha="right");plt.tight_layout();plt.show()

fig,ax=plt.subplots(figsize=(8,5));ax.scatter(properties.MolecularWeight,properties.TPSA,s=40)
for row in properties.itertuples():ax.annotate(row.name,(row.MolecularWeight,row.TPSA),fontsize=8,xytext=(4,4),textcoords="offset points")
ax.set(xlabel="Calculated molar mass (g/mol)",ylabel="Calculated TPSA (Ų)",title="Reported descriptors, not a biological assay");plt.tight_layout();plt.show()

assert np.allclose(fraction.sum(axis=1),1)
assert np.max(abs(comparison.difference_g_per_mol))<.03
try:parse_simple_formula("Mg(OH)2")
except ValueError:print("Grouped formula rejected by the declared simple parser")
else:raise AssertionError("Unsupported syntax silently accepted")
OUTPUT_DIR.mkdir(parents=True,exist_ok=True);comparison.to_csv(OUTPUT_DIR/"molar-mass-reconciliation.csv")
fraction.to_csv(OUTPUT_DIR/"elemental-mass-fractions.csv")
(OUTPUT_DIR/"atomic-weights.json").write_text(json.dumps(atomic_weights,indent=2))
print("Mass and fraction checks passed; exports:",OUTPUT_DIR)

Grouped formula rejected by the declared simple parser
Mass and fraction checks passed; exports: /Users/zhiluo/Developer/vibeit-cookbook/cookbook/downloads/results/ch01-molecular-formulas

RUN_ONLINE_UPDATE=False
if RUN_ONLINE_UPDATE:
    import requests
    try:
        response=requests.get('https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/cid/2519/property/MolecularFormula/JSON',timeout=20)
        response.raise_for_status()
        print("Source:",response.url)
        print(response.text[:700])
    except requests.RequestException as error:
        print("Online extension unavailable:",type(error).__name__,str(error)[:160])
else:
    print("Online extension skipped; embedded core data unchanged")

Online extension skipped; embedded core data unchanged