finalcif 175__tar.gz → 177__tar.gz

{finalcif-175 → finalcif-177}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: finalcif
-Version: 175
+Version: 177
 Summary: CIF file editor
 Project-URL: Homepage, https://dkratzert.de/finalcif.html
 Project-URL: Bug Tracker, https://github.com/dkratzert/FinalCif/issues

finalcif-177/finalcif/__init__.py

@@ -0,0 +1,3 @@
+
+VERSION = 177
+__version__ = VERSION

{finalcif-175 → finalcif-177}/finalcif/appwindow.py

@@ -1311,15 +1311,15 @@ class AppWindow(QMainWindow):
                 self.validation_response_forms_list.append(vrf)
                 table.place_vrf_widget(insert_pos, vrf)
 
-        if html_entries:
-            n = len(html_entries)
-            form_noun = 'form' if n == 1 else 'forms'
-            self.ui.CheckCifLogPlainTextEdit.appendHtml(
-                f'<br><b>{n} validation response forms {form_noun} added to the main table.</b>')
-        else:
-            levels = 'A, B or C' if self.ui.explainCandGAlertsCheckBox.isChecked() else 'A or B'
-            self.ui.CheckCifLogPlainTextEdit.appendHtml(
-                f'<br><b>No level {levels} alerts require a response.</b>')
+        self.ui.CheckCifLogPlainTextEdit.appendHtml(self._vrf_summary_message(len(html_entries)))
+
+    def _vrf_summary_message(self, count: int) -> str:
+        """Return the log message summarizing how many VRFs a CheckCIF run produced."""
+        if count:
+            form_noun = 'form' if count == 1 else 'forms'
+            return f'<br><b>{count} validation response {form_noun} added to the main table.</b>'
+        levels = 'A, B or C' if self.ui.explainCAlertsCheckBox.isChecked() else 'A or B'
+        return f'<br><b>No level {levels} alerts require a response.</b>'
 
     def _vrf_insert_position(self) -> int:
         """Return the row index just after the last existing ``_vrf_*`` row in the main table.

{finalcif-175 → finalcif-177}/finalcif/cif/hkl.py

@@ -34,10 +34,7 @@ class HKL:
 
     @property
     def hkl_as_cif(self) -> str:
-        if version.parse(gemmi.__version__) < version.parse('0.5.1'):
-            return self._doc.as_string(style=Style.Simple)
-        else:
-            return self._doc.as_string(options=gemmi.cif.WriteOptions(Style.Simple))
+        return self._doc.as_string(options=gemmi.cif.WriteOptions(Style.Simple))
 
     def _add_hkl_as_loop(self) -> None:
         """

{finalcif-175 → finalcif-177}/finalcif/gui/finalcif_gui_ui.py

@@ -2881,7 +2881,7 @@ class Ui_FinalCifWindow(object):
         self.CancelPropertiesButton.setText(QCoreApplication.translate("FinalCifWindow", u"Cancel", None))
         self.ExportPropertyButton.setText(QCoreApplication.translate("FinalCifWindow", u"Export", None))
         self.BackFromLoopsPushButton.setText(QCoreApplication.translate("FinalCifWindow", u"Back to CIF Table", None))
-        self.add_squeeze_pushButton.setText(QCoreApplication.translate("FinalCifWindow", u"Add Squeeze Info", None))
+        self.add_squeeze_pushButton.setText(QCoreApplication.translate("FinalCifWindow", u"Add/Edit Squeeze Info", None))
         self.deleteLoopButton.setText(QCoreApplication.translate("FinalCifWindow", u"Delete Loop", None))
         self.newLoopPushButton.setText(QCoreApplication.translate("FinalCifWindow", u"Add New Loop", None))
         self.revertLoopsPushButton.setText(QCoreApplication.translate("FinalCifWindow", u"Revert Changes", None))

{finalcif-175 → finalcif-177}/finalcif/gui/finalcif_gui_ui.ui

@@ -2861,7 +2861,7 @@ The data source will be ignored until next program restart.</string>
               <item row="0" column="2">
                <widget class="QPushButton" name="add_squeeze_pushButton">
                 <property name="text">
-                 <string>Add Squeeze Info</string>
+                 <string>Add/Edit Squeeze Info</string>
                 </property>
                </widget>
               </item>

{finalcif-175 → finalcif-177}/finalcif/gui/squeeze_dialog.py

@@ -18,14 +18,15 @@ from pathlib import Path
 from qtpy import QtCore, compat
 from qtpy.QtGui import QColor
 from qtpy.QtWidgets import (
-    QDialog, QDialogButtonBox, QHBoxLayout, QLabel, QMessageBox,
-    QPlainTextEdit, QPushButton, QSizePolicy, QTableWidget, QTableWidgetItem,
+    QAbstractItemView, QCompleter, QDialog, QDialogButtonBox, QHBoxLayout, QLabel, QLineEdit, QMessageBox,
+    QPlainTextEdit, QPushButton, QSizePolicy, QStyledItemDelegate, QTableWidget, QTableWidgetItem,
     QVBoxLayout, QWidget, QApplication
 )
 
 from finalcif.cif.cif_file_io import CifContainer
-from finalcif.cif.text import quote
-from finalcif.tools.squeeze import build_details_text, electrons_from_formula
+from finalcif.cif.text import quote, retranslate_delimiter
+from finalcif.tools.solvents import solvent_names
+from finalcif.tools.squeeze import build_details_text, electrons_from_formula, resolve_formula
 
 
 class SqueezeMode(Enum):
@@ -78,7 +79,9 @@ _MODE_CONFIG: dict[SqueezeMode, dict] = {
         'details_key'         : '_platon_squeeze_details',
         'title'               : 'PLATON SQUEEZE \u2013 Assign Solvent Content',
         'info'                : ('PLATON/SQUEEZE was used. '
-                                 'Assign the solvent formula per void <b>per unit cell</b>, e.g. <tt>2(H2O)</tt>.'),
+                                 'Assign the solvent formula per void <b>per unit cell</b>, e.g. <tt>2(H2O)</tt>.\n'
+                                 'Common solvent names like <tt>2 thf</tt> or <tt>toluene</tt> are '
+                                 'converted to their formula.'),
         'details_label'       : 'SQUEEZE details (<i>_platon_squeeze_details</i>):',
         'electrons_col_header': 'Electrons\n(PLATON)',
     },
@@ -91,7 +94,9 @@ _MODE_CONFIG: dict[SqueezeMode, dict] = {
         'details_key'         : '_smtbx_masks_special_details',
         'title'               : 'Olex2/SMTBX Masks \u2013 Assign Solvent Content',
         'info'                : ('Olex2/SMTBX solvent masks were used. '
-                                 'Assign the solvent formula per void <b>per unit cell</b>, e.g. <tt>2(H2O)</tt>.'),
+                                 'Assign the solvent formula per void <b>per unit cell</b>, e.g. <tt>2(H2O)</tt>.\n'
+                                 'Common solvent names like <tt>2 thf</tt> or <tt>toluene</tt> are '
+                                 'converted to their formula.'),
         'details_label'       : 'Masks details (<i>_smtbx_masks_special_details</i>):',
         'electrons_col_header': 'Electrons\n(Masks)',
     },
@@ -102,6 +107,19 @@ _COLOR_WARN = QColor(255, 200, 200)  # light red
 _COLOR_NEUTRAL = QColor(255, 255, 255)  # white
 
 
+class SolventNameDelegate(QStyledItemDelegate):
+    """Line edit delegate that autocompletes common solvent names."""
+
+    def createEditor(self, parent: QWidget, option, index) -> QWidget:
+        editor = QLineEdit(parent)
+        completer = QCompleter(solvent_names(), editor)
+        completer.setCaseSensitivity(QtCore.Qt.CaseSensitivity.CaseInsensitive)
+        completer.setFilterMode(QtCore.Qt.MatchFlag.MatchContains)
+        completer.setCompletionMode(QCompleter.CompletionMode.PopupCompletion)
+        editor.setCompleter(completer)
+        return editor
+
+
 class SqueezeSolventDialog(QDialog):
     """
     Modal dialog for entering PLATON SQUEEZE or Olex2/SMTBX solvent mask content.
@@ -212,6 +230,15 @@ class SqueezeSolventDialog(QDialog):
         self.table.setColumnWidth(_COL_FORMULA, 160)
         self.table.setColumnWidth(_COL_ELEC_CALC, 85)
         self.table.verticalHeader().setVisible(False)
+        self.table.setEditTriggers(
+            QAbstractItemView.EditTrigger.CurrentChanged
+            | QAbstractItemView.EditTrigger.SelectedClicked
+            | QAbstractItemView.EditTrigger.DoubleClicked
+            | QAbstractItemView.EditTrigger.AnyKeyPressed
+            | QAbstractItemView.EditTrigger.EditKeyPressed
+        )
+        self._solvent_delegate = SolventNameDelegate(self.table)
+        self.table.setItemDelegateForColumn(_COL_FORMULA, self._solvent_delegate)
         self.table.itemChanged.connect(self._on_formula_changed)
         layout.addWidget(self.table)
 
@@ -242,7 +269,7 @@ class SqueezeSolventDialog(QDialog):
         existing_details = self.cif[self._cfg['details_key']]
         if existing_details:
             self._details_user_modified = True
-            self.details_edit.setPlainText(existing_details)
+            self.details_edit.setPlainText(retranslate_delimiter(existing_details))
         self.details_edit.textChanged.connect(self._on_details_text_changed)
 
         # button box
@@ -408,9 +435,25 @@ class SqueezeSolventDialog(QDialog):
     def _on_formula_changed(self, item: QTableWidgetItem) -> None:
         if item.column() != _COL_FORMULA:
             return
+        self._resolve_item_formula(item)
         self._update_row_calculations(item.row())
         self._regenerate_details()
 
+    @staticmethod
+    def _resolve_item_formula(item: QTableWidgetItem) -> None:
+        """Replace a solvent name in *item* by its sum formula."""
+        text = item.text()
+        resolved = resolve_formula(text)
+        if resolved == text:
+            return
+        table = item.tableWidget()
+        blocked = table.signalsBlocked() if table else True
+        if table:
+            table.blockSignals(True)
+        item.setText(resolved)
+        if table:
+            table.blockSignals(blocked)
+
     def _update_row_calculations(self, row_idx: int) -> None:
         """Recalculate Electrons (calc.) and Δ for a given row."""
         formula_item = self.table.item(row_idx, _COL_FORMULA)
@@ -458,6 +501,7 @@ class SqueezeSolventDialog(QDialog):
             item = self.table.item(row_idx, _COL_FORMULA)
             if item:
                 item.setText(formula)
+                self._resolve_item_formula(item)
             self._update_row_calculations(row_idx)
         self.table.blockSignals(False)
         self._regenerate_details()
@@ -475,7 +519,7 @@ class SqueezeSolventDialog(QDialog):
                 'nr'              : row_idx + 1,
                 'volume'          : vol_item.text() if vol_item else '?',
                 'electrons_platon': elec_item.text() if elec_item else '?',
-                'formula'         : formula_item.text() if formula_item else '',
+                'formula'         : resolve_formula(formula_item.text()) if formula_item else '',
             })
         text = build_details_text(void_rows, method=self._loop_mode.value)
         # Block textChanged so our programmatic update doesn't set _details_user_modified
@@ -513,7 +557,7 @@ class SqueezeSolventDialog(QDialog):
         new_formulae: list[str] = []
         for row_idx in range(n_rows):
             item = self.table.item(row_idx, _COL_FORMULA)
-            formula = item.text().strip() if item else '?'
+            formula = resolve_formula(item.text()).strip() if item else '?'
             new_formulae.append(quote(formula) if formula else '?')
 
         # Reconstruct column data with the updated content column

{finalcif-175 → finalcif-177}/finalcif/gui/validators.py

@@ -147,6 +147,15 @@ class Textlimits:
         return False
 
 
+class AnyTextLimits:
+    def __init__(self, help_text: str | None = None):
+        self.valid = self.validate_cif_key
+        self.help_text = help_text or 'Any text is allowed.'
+
+    def validate_cif_key(self, value: str) -> bool:
+        return True
+
+
 validators: dict[str, BaseLimits] = {
     '_database_code_depnum_ccdc_archive'   : Integerlimits(lower=0, upper=inf),
     '_cell_measurement_reflns_used'        : Integerlimits(lower=0, upper=inf),
@@ -279,7 +288,7 @@ validators: dict[str, BaseLimits] = {
                                                                  'DGRS']),
     '_atom_site_refinement_flags_adp'      : Textlimits(options=['None', 'T', 'U', 'TU']),
     '_atom_site_refinement_flags_occupancy': Textlimits(options=['None', 'P']),
-    '_atom_site_disorder_assembly'         : Textlimits(options=['A', 'B', 'S']),
+    '_atom_site_disorder_assembly'         : AnyTextLimits(),
     '_atom_site_aniso_U_11'                : Floatlimits(),
     '_atom_site_aniso_U_22'                : Floatlimits(),
     '_atom_site_aniso_U_33'                : Floatlimits(),

{finalcif-175 → finalcif-177}/finalcif/tools/shred.py

@@ -68,7 +68,7 @@ class ShredCIF:
             if line.startswith(')'):
                 line = ';' + line[1:]
             lines.append(line)
-        return '\n'.join(lines).lstrip('\n')
+        return '\n'.join(lines).lstrip('\n\r')
 
     def _show_info(self, resname: Path, hklname: Path, resdata: str | None, hkldata: str | None) -> None:
         if resdata and not hkldata:

finalcif-177/finalcif/tools/solvents.py

@@ -0,0 +1,183 @@
+#   ----------------------------------------------------------------------------
+#   "THE BEER-WARE LICENSE" (Revision 42):
+#   <dkratzert@gmx.de> wrote this file.  As long as you retain
+#   this notice you can do whatever you want with this stuff. If we meet some day,
+#   and you think this stuff is worth it, you can buy me a beer in return.
+#   Dr. Daniel Kratzert
+#   ----------------------------------------------------------------------------
+"""
+Lookup table that translates common solvent names into chemical formulae.
+
+This allows users to type ``thf``, ``water`` or ``2 toluene`` instead of the
+corresponding sum formula when assigning solvent content to voids.
+"""
+from __future__ import annotations
+
+import re
+
+# Canonical solvent name -> sum formula.
+SOLVENTS: dict[str, str] = {
+    'water'                  : 'H2O',
+    'methanol'               : 'CH4O',
+    'ethanol'                : 'C2H6O',
+    '1-propanol'             : 'C3H8O',
+    '2-propanol'             : 'C3H8O',
+    '1-butanol'              : 'C4H10O',
+    'tert-butanol'           : 'C4H10O',
+    'ethylene glycol'        : 'C2H6O2',
+    'acetone'                : 'C3H6O',
+    'acetonitrile'           : 'C2H3N',
+    'acetic acid'            : 'C2H4O2',
+    'ethyl acetate'          : 'C4H8O2',
+    'formic acid'            : 'CH2O2',
+    'tetrahydrofuran'        : 'C4H8O',
+    '2-methyltetrahydrofuran': 'C5H10O',
+    'tetrahydropyran'        : 'C5H10O',
+    '1,4-dioxane'            : 'C4H8O2',
+    'diethyl ether'          : 'C4H10O',
+    'diisopropyl ether'      : 'C6H14O',
+    'tert-butyl methyl ether': 'C5H12O',
+    'dimethoxyethane'        : 'C4H10O2',
+    'diglyme'                : 'C6H14O3',
+    'anisole'                : 'C7H8O',
+    'dichloromethane'        : 'CH2Cl2',
+    'chloroform'             : 'CHCl3',
+    'carbon tetrachloride'   : 'CCl4',
+    '1,2-dichloroethane'     : 'C2H4Cl2',
+    'carbon disulfide'       : 'CS2',
+    'benzene'                : 'C6H6',
+    'toluene'                : 'C7H8',
+    'xylene'                 : 'C8H10',
+    'mesitylene'             : 'C9H12',
+    'chlorobenzene'          : 'C6H5Cl',
+    '1,2-dichlorobenzene'    : 'C6H4Cl2',
+    'bromobenzene'           : 'C6H5Br',
+    'fluorobenzene'          : 'C6H5F',
+    '1,2-difluorobenzene'    : 'C6H4F2',
+    'nitrobenzene'           : 'C6H5NO2',
+    'nitromethane'           : 'CH3NO2',
+    'pentane'                : 'C5H12',
+    'hexane'                 : 'C6H14',
+    'heptane'                : 'C7H16',
+    'octane'                 : 'C8H18',
+    'cyclohexane'            : 'C6H12',
+    'cyclopentane'           : 'C5H10',
+    'pyridine'               : 'C5H5N',
+    'triethylamine'          : 'C6H15N',
+    'dimethylformamide'      : 'C3H7NO',
+    'dimethylacetamide'      : 'C4H9NO',
+    'dimethyl sulfoxide'     : 'C2H6OS',
+    'n-methylpyrrolidone'    : 'C5H9NO',
+    'hexamethylphosphoramide': 'C6H18N3OP',
+    'sulfolane'              : 'C4H8O2S',
+    'aniline'                : 'C6H7N',
+    'ammonia'                : 'H3N',
+    'hydrazine'              : 'H4N2',
+}
+
+# Alias -> canonical solvent name.  Aliases must not look like a valid sum
+# formula, otherwise a formula would silently be reinterpreted as a name.
+ALIASES: dict[str, str] = {
+    'h2o'                   : 'water',
+    'aqua'                  : 'water',
+    'meoh'                  : 'methanol',
+    'etoh'                  : 'ethanol',
+    'cyclohexan'            : 'cyclohexane',
+    'n-propanol'            : '1-propanol',
+    'propanol'              : '2-propanol',
+    'isopropanol'           : '2-propanol',
+    'iso-propanol'          : '2-propanol',
+    'ipa'                   : '2-propanol',
+    'iproh'                 : '2-propanol',
+    'n-butanol'             : '1-butanol',
+    'butanol'               : '1-butanol',
+    't-butanol'             : 'tert-butanol',
+    'tert-butyl alcohol'    : 'tert-butanol',
+    'tbuoh'                 : 'tert-butanol',
+    'glycol'                : 'ethylene glycol',
+    'aceton'                : 'acetone',
+    'mecn'                  : 'acetonitrile',
+    'ch3cn'                 : 'acetonitrile',
+    'etoac'                 : 'ethyl acetate',
+    'ethylacetate'          : 'ethyl acetate',
+    'thf'                   : 'tetrahydrofuran',
+    'me-thf'                : '2-methyltetrahydrofuran',
+    '2-me-thf'              : '2-methyltetrahydrofuran',
+    '2-methyl-thf'          : '2-methyltetrahydrofuran',
+    'methf'                 : '2-methyltetrahydrofuran',
+    'thp'                   : 'tetrahydropyran',
+    'dioxane'               : '1,4-dioxane',
+    'ether'                 : 'diethyl ether',
+    'et2o'                  : 'diethyl ether',
+    'diethylether'          : 'diethyl ether',
+    'ipr2o'                 : 'diisopropyl ether',
+    'mtbe'                  : 'tert-butyl methyl ether',
+    'tbme'                  : 'tert-butyl methyl ether',
+    'dme'                   : 'dimethoxyethane',
+    'glyme'                 : 'dimethoxyethane',
+    '1,2-dimethoxyethane'   : 'dimethoxyethane',
+    'methoxybenzene'        : 'anisole',
+    'dcm'                   : 'dichloromethane',
+    'methylene chloride'    : 'dichloromethane',
+    'methylenechloride'     : 'dichloromethane',
+    'dce'                   : '1,2-dichloroethane',
+    'benzol'                : 'benzene',
+    'toluol'                : 'toluene',
+    'tol'                   : 'toluene',
+    'p-xylene'              : 'xylene',
+    'o-xylene'              : 'xylene',
+    'm-xylene'              : 'xylene',
+    'xylol'                 : 'xylene',
+    '1,3,5-trimethylbenzene': 'mesitylene',
+    'odcb'                  : '1,2-dichlorobenzene',
+    'dfb'                   : '1,2-difluorobenzene',
+    'n-pentane'             : 'pentane',
+    'n-hexane'              : 'hexane',
+    'n-heptane'             : 'heptane',
+    'n-octane'              : 'octane',
+    'pyr'                   : 'pyridine',
+    'py'                    : 'pyridine',
+    'net3'                  : 'triethylamine',
+    'et3n'                  : 'triethylamine',
+    'dmf'                   : 'dimethylformamide',
+    'n,n-dimethylformamide' : 'dimethylformamide',
+    'dma'                   : 'dimethylacetamide',
+    'n,n-dimethylacetamide' : 'dimethylacetamide',
+    'dmso'                  : 'dimethyl sulfoxide',
+    'dimethylsulfoxide'     : 'dimethyl sulfoxide',
+    'nmp'                   : 'n-methylpyrrolidone',
+    'n-methyl-2-pyrrolidone': 'n-methylpyrrolidone',
+    'hmpa'                  : 'hexamethylphosphoramide',
+    'tetramethylene sulfone': 'sulfolane',
+    'aminobenzene'          : 'aniline',
+}
+
+_NORMALIZE_RE = re.compile(r'[\s_]+')
+
+
+def _norm(name: str) -> str:
+    """Normalize a solvent name for case- and whitespace-insensitive lookup."""
+    return _NORMALIZE_RE.sub(' ', name.strip().lower()).replace(' ', '')
+
+
+_LOOKUP: dict[str, str] = {_norm(name): formula for name, formula in SOLVENTS.items()}
+_LOOKUP.update({_norm(alias): SOLVENTS[canonical] for alias, canonical in ALIASES.items()})
+
+
+def resolve_solvent(name: str) -> str | None:
+    """Return the sum formula for a solvent name or alias.
+
+    Args:
+        name: Solvent name such as ``'thf'``, ``'Water'`` or ``'diethyl ether'``.
+
+    Returns:
+        The sum formula, or ``None`` when *name* is not a known solvent.
+    """
+    if not name:
+        return None
+    return _LOOKUP.get(_norm(name))
+
+
+def solvent_names() -> list[str]:
+    """Return all canonical solvent names and aliases, sorted alphabetically."""
+    return sorted(set(SOLVENTS) | set(ALIASES))

{finalcif-175 → finalcif-177}/finalcif/tools/squeeze.py

@@ -15,6 +15,7 @@ from typing import Literal, TYPE_CHECKING
 
 from finalcif.cif.atoms import element2num
 from finalcif.tools.chemparse import parse_formula, ChemparseError
+from finalcif.tools.solvents import resolve_solvent
 
 if TYPE_CHECKING:
     from finalcif.cif.cif_file_io import CifContainer
@@ -22,6 +23,42 @@ if TYPE_CHECKING:
 # Atomic numbers (= electron count for neutral atoms) for elements common in crystallography.
 ATOMIC_NUMBERS: dict[str, int] = element2num
 
+# Splits an optional leading multiplier from the rest, e.g. '2(thf)' or '2 thf'.
+_MULTIPLIER_RE = re.compile(r'^(\d+(?:\.\d+)?)\s*(.*)$', re.DOTALL)
+
+
+def resolve_formula(text: str) -> str:
+    """Translate a solvent name into its sum formula.
+
+    Accepts an optional leading multiplier, so ``'thf'``, ``'2 thf'`` and
+    ``'2(thf)'`` all resolve.  Text that does not name a known solvent is
+    returned unchanged, which keeps ordinary formulae such as ``'2(H2O)'``
+    working.
+
+    Args:
+        text: User input, e.g. ``'2 toluene'``.
+
+    Returns:
+        A formula string such as ``'2(C7H8)'``, or *text* unchanged.
+    """
+    stripped = text.strip()
+    if not stripped:
+        return text
+    multiplier = ''
+    remainder = stripped
+    match = _MULTIPLIER_RE.match(stripped)
+    if match:
+        multiplier, remainder = match.group(1), match.group(2).strip()
+    remainder = remainder.strip()
+    if remainder.startswith('(') and remainder.endswith(')'):
+        remainder = remainder[1:-1].strip()
+    formula = resolve_solvent(remainder)
+    if formula is None:
+        return stripped
+    if not multiplier or float(multiplier) == 1:
+        return formula
+    return f'{multiplier}({formula})'
+
 
 def _normalize_squeeze_formula(formula_str: str) -> str:
     """
@@ -80,11 +117,12 @@ def electrons_from_formula(formula_str: str) -> int:
     """
     Returns the total electron count for a chemical formula string.
 
-    Supports standard crystallographic formulae such as 'C4H8O', '2(H2O)', 'CHCl3'.
+    Supports standard crystallographic formulae such as 'C4H8O', '2(H2O)', 'CHCl3'
+    as well as common solvent names like 'thf' or '2 toluene'.
     Unknown elements contribute 0 electrons.  Returns 0 for empty / placeholder strings.
 
     Args:
-        formula_str: Chemical formula, e.g. '2(C4H8O)' or 'H2O'.
+        formula_str: Chemical formula, e.g. '2(C4H8O)', 'H2O' or '2 thf'.
 
     Returns:
         Integer electron count, or 0 when the formula cannot be parsed.
@@ -92,7 +130,7 @@ def electrons_from_formula(formula_str: str) -> int:
     if not formula_str or formula_str.strip() in ('?', '.', ''):
         return 0
     try:
-        normalised = _normalize_squeeze_formula(formula_str.strip())
+        normalised = _normalize_squeeze_formula(resolve_formula(formula_str))
         atom_dict = parse_formula(normalised)
         return round(sum(ATOMIC_NUMBERS.get(el, 0) * count for el, count in atom_dict.items()))
     except ChemparseError: