finalcif 170__tar.gz → 172__tar.gz

{finalcif-170 → finalcif-172}/.gitignore

@@ -241,3 +241,5 @@ finalcif_keys_order.cif
 /work/dicts/cif_ms.dic
 /work/dicts/cif_pow.dic
 /work/dicts/ddl.dic
+/test-data/4060314-finalcif.zip
+/test-data/report_4060314-finalcif.html

{finalcif-170 → finalcif-172}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: finalcif
-Version: 170
+Version: 172
 Summary: CIF file editor
 Project-URL: Homepage, https://dkratzert.de/finalcif.html
 Project-URL: Bug Tracker, https://github.com/dkratzert/FinalCif/issues
@@ -17,7 +17,7 @@ Requires-Dist: chardet
 Requires-Dist: charset-normalizer
 Requires-Dist: docxcompose==2.2.0
 Requires-Dist: docxtpl[subdoc]>=0.20.2
-Requires-Dist: fastmolwidget>=0.9.7
+Requires-Dist: fastmolwidget>=1.0.0
 Requires-Dist: gemmi>=0.7.5
 Requires-Dist: html2text
 Requires-Dist: lxml>=6.1.1

finalcif-172/finalcif/__init__.py

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

{finalcif-170 → finalcif-172}/finalcif/appwindow.py

@@ -14,18 +14,19 @@ import sys
 import threading
 import time
 import warnings
+from collections.abc import Callable
 from contextlib import suppress
 from datetime import datetime
 from math import sin, radians
 from pathlib import Path, WindowsPath
 from typing import cast, TYPE_CHECKING
 
+
 if TYPE_CHECKING:
     from finalcif.cif.checkcif.checkcif import MyHTMLParser
 
 from fastmolwidget import Atomtuple
 from fastmolwidget.part_combo import PartFilterWidget
-from fastmolwidget.sdm import SDM
 
 from finalcif.gui.shelx_navigation import find_shelx_line_for_atom, scroll_and_highlight_shelx_atom
 from finalcif.gui.syntax_highlighter import ShelxSyntaxHighlighter
@@ -60,7 +61,7 @@ from finalcif.gui.custom_classes import Column, light_green, yellow, light_blue,
     white, light_red, MyTableWidgetItem, blue
 from finalcif.gui.cif_table_model import CifRowData
 from finalcif.gui.dialogs import show_update_warning, unable_to_open_message, show_general_warning, \
-    cif_file_open_dialog, \
+    cif_file_open_dialog, fcf_file_open_dialog, \
     bad_z_message, show_res_checksum_warning, show_hkl_checksum_warning, cif_file_save_dialog, show_yes_now_question, \
     video_file_open_dialog
 from finalcif.gui.finalcif_gui_ui import Ui_FinalCifWindow
@@ -76,6 +77,7 @@ from finalcif.gui.vrf_classes import MyVRFContainer
 from finalcif.template.templates import ReportTemplates
 from finalcif.tools.download import MyDownloader
 from finalcif.tools.dsrmath import my_isnumeric
+from finalcif.tools.mol_file_writer import grown_atoms
 from finalcif.tools.misc import (next_path, celltxt, to_float, is_database_number,
                                  open_file, strip_finalcif_of_name, file_age_in_days, open_in_text_editor,
                                  running_inside_unit_test as is_unit_test)
@@ -163,8 +165,10 @@ class AppWindow(QMainWindow):
         super().__init__()
         self.thread_download = None
         self.ckf = None
+        self.htmlfile: Path | None = None
+        self.pdf_htmlfile: Path | None = None
         self.thread_version = None
-        self.worker = None
+        self._downloaders: set[MyDownloader] = set()
         self._z_thread: _ZEstimatorThread | None = None
         self.structure_factor_thread: _StructureFactorReportThread | None = None
         self.setAttribute(QtCore.Qt.WidgetAttribute.WA_DeleteOnClose)
@@ -989,11 +993,36 @@ class AppWindow(QMainWindow):
             print('Skipping version.txt download because NO_NETWORK variable is set.')
             return
         mainurl = "https://dkratzert.de/files/finalcif/version.txt"
-        # parent must be None, otherwise it can't be moved to a thread:
-        self.worker = MyDownloader(mainurl, parent=None)
-        self.worker.loaded.connect(self.is_update_necessary)
-        self.thread_version = threading.Thread(target=self.worker.download, daemon=True)
-        self.thread_version.start()
+        self.thread_version = self._start_download(mainurl, self.is_update_necessary)
+
+    def _start_download(self, url: str, on_loaded: Callable[[bytes], None]) -> threading.Thread:
+        """Download `url` in a daemon thread and hand the content to `on_loaded`.
+
+        The worker must not have a parent, otherwise it could not be moved to a thread, so it
+        is kept in `_downloaders` until it is done.  Without that reference it would be
+        garbage collected as soon as the next download starts, and its queued signals would
+        never reach the main thread.
+        """
+        worker = MyDownloader(url, parent=None)
+        self._downloaders.add(worker)
+        worker.loaded.connect(on_loaded)
+        worker.failed.connect(self._download_failed)
+        worker.finished.connect(self._download_finished)
+        thread = threading.Thread(target=worker.download, daemon=True)
+        thread.start()
+        return thread
+
+    def _download_finished(self) -> None:
+        # These slots run in the main thread, so 'loaded' was already delivered here:
+        self._forget_downloader(cast(MyDownloader, self.sender()))
+
+    def _download_failed(self, status_code: int) -> None:
+        worker = cast(MyDownloader, self.sender())
+        print(f'Download of {worker.url} failed with status code {status_code}.')
+        self._forget_downloader(worker)
+
+    def _forget_downloader(self, worker: MyDownloader) -> None:
+        self._downloaders = {each for each in self._downloaders if each is not worker}
 
     def is_update_necessary(self, content: bytes) -> None:
         """
@@ -1060,10 +1089,7 @@ class AppWindow(QMainWindow):
             print('Skipping check.def download because NO_NETWORK variable is set.')
             return
         url = 'http://www.platonsoft.nl/xraysoft/unix/platon/check.def'
-        self.worker = MyDownloader(url, parent=None)
-        self.worker.loaded.connect(self._save_checkdef)
-        self.thread_download = threading.Thread(target=self.worker.download, daemon=True)
-        self.thread_download.start()
+        self.thread_download = self._start_download(url, self._save_checkdef)
 
     def _save_checkdef(self, reply: bytes) -> None:
         """
@@ -1150,6 +1176,53 @@ class AppWindow(QMainWindow):
     def _checkcif_failed(self, txt: str) -> None:
         self.ui.CheckCifLogPlainTextEdit.appendHtml(f'<b>{txt}</b>')
 
+    def _log_checkcif(self, txt: str) -> None:
+        self.ui.CheckCifLogPlainTextEdit.appendPlainText(txt)
+        app.processEvents()
+
+    def _resolve_structure_factor_upload(self, html_file: Path) -> None:
+        """
+        Answers the CheckCIF page that asks for an explicit upload of the structure factor file.
+
+        The structure factor file belonging to the current CIF is searched next to it. If no
+        matching file is found, the user is asked for one. When the user cancels the dialog, the
+        check is continued without the remaining structure factors.
+        """
+        from finalcif.cif.checkcif.checkcif import (fix_iucr_urls, needs_structure_factor_upload,
+                                                    submit_without_structure_factors, upload_structure_factors)
+        try:
+            html = html_file.read_text('utf-8', 'ignore')
+        except OSError:
+            return
+        if not needs_structure_factor_upload(html):
+            return
+        self.ui.CheckCifLogPlainTextEdit.appendHtml(
+            '<b>CheckCIF requests the structure factor file for this CIF.</b>')
+        app.processEvents()
+        fcf_file = self._get_structure_factor_file()
+        if fcf_file:
+            new_html = upload_structure_factors(response_html=html, fcf_file=fcf_file,
+                                                url=self.options.checkcif_url, progress=self._log_checkcif)
+        else:
+            self._log_checkcif('No structure factor file selected. '
+                               'Continuing without the remaining structure factors.')
+            new_html = submit_without_structure_factors(response_html=html, url=self.options.checkcif_url,
+                                                        progress=self._log_checkcif)
+        if new_html == html:
+            return
+        with suppress(OSError):
+            html_file.write_text(fix_iucr_urls(new_html), encoding='utf-8')
+
+    def _get_structure_factor_file(self) -> Path | None:
+        from finalcif.cif.checkcif.checkcif import find_matching_fcf_file
+        fcf_file = find_matching_fcf_file(self.cif.finalcif_file)
+        if fcf_file:
+            self._log_checkcif(f'Found structure factor file {fcf_file.name}.')
+            return fcf_file
+        self._log_checkcif('No structure factor file found for the current CIF. Please select one.')
+        filename = fcf_file_open_dialog(parent=self, last_dir=str(self.cif.finalcif_file.parent))
+        return Path(filename) if filename else None
+
     def _ckf_progress(self, txt: str) -> None:
         self.ui.CheckCifLogPlainTextEdit.appendPlainText(txt)
 
@@ -1160,6 +1233,9 @@ class AppWindow(QMainWindow):
         from finalcif.cif.checkcif.checkcif import MyHTMLParser, AlertHelp
         self.ui.CheckcifHTMLOnlineButton.setEnabled(True)
         self.ui.CheckcifPDFOnlineButton.setEnabled(True)
+
+        self._resolve_structure_factor_upload(self.htmlfile)
+
         try:
             parser = MyHTMLParser(self.htmlfile.read_text())
         except FileNotFoundError:
@@ -1167,22 +1243,27 @@ class AppWindow(QMainWindow):
             self.ui.CheckCifLogPlainTextEdit.appendHtml('<b>CheckCIF failed to finish. '
                                                         'Please try it at https://checkcif.iucr.org/ instead.</b>')
             return
+
         self.checkcif_browser = CheckCifBrowser(parent=self, checkdef=self.checkdef)
         self.ui.htmlCHeckCifGridLayout.addWidget(self.checkcif_browser)
         self.ui.MainStackedWidget.go_to_checkcif_page()
         self.ui.CheckCIFResultsTabWidget.setCurrentIndex(1)  # Index 1 is html page
+
         # Save the structure image locally and point the HTML to it. The remote image URL
         # is session-specific and expires, so the locally saved copy is used for display.
         gif_file = self.cif.finalcif_file.with_suffix('.gif')
         parser.save_image(gif_file)
+
         try:
             html = self.htmlfile.resolve().read_text('utf-8', 'ignore')
             local_images = {parser.imageurl: gif_file} if parser.imageurl else {}
             self.checkcif_browser.set_checkcif_html(html, local_images)
         except FileNotFoundError:
             print(f'{self.htmlfile} not found')
+
         self._display_structure_factor_report(parser)
         self.ui.CheckCifLogPlainTextEdit.appendPlainText('CheckCIF Report finished.')
+
         html_entries = parser.response_forms
         # Merge HTML-parsed entries into the main table:
         # - Entries already shown in the main table (source='cif') get their source badge
@@ -1192,6 +1273,7 @@ class AppWindow(QMainWindow):
         #   the main table, marked 'checkcif'.
         a = AlertHelp(self.checkdef)
         table = self.ui.cif_main_table
+
         # Build a lookup of already-saved CIF VRF entries once, outside the loop.
         existing_by_key = {e.key: e for e in self.cif.get_vrf_entries()}
         for entry in html_entries:
@@ -1216,6 +1298,7 @@ class AppWindow(QMainWindow):
                 vrf.template_requested.connect(self._on_vrf_template_requested)
                 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'
@@ -1309,6 +1392,14 @@ class AppWindow(QMainWindow):
     def _pdf_checkcif_finished(self) -> None:
         self.ui.CheckcifPDFOnlineButton.setEnabled(True)
         self.ui.CheckcifHTMLOnlineButton.setEnabled(True)
+        if self.pdf_htmlfile is None:
+            return
+        self._resolve_structure_factor_upload(self.pdf_htmlfile)
+        self.ckf.show_pdf_report()
+        self.ui.CheckCifLogPlainTextEdit.appendPlainText('PDF Checkcif report finished.')
+        with suppress(OSError):
+            self.pdf_htmlfile.unlink(missing_ok=True)
+        self.pdf_htmlfile = None
 
     def _on_vrf_deleted(self, vrf_widget) -> None:
         """
@@ -1360,14 +1451,14 @@ class AppWindow(QMainWindow):
             self.ui.CheckCifLogPlainTextEdit.appendHtml('<b>Unable to save CIF file. Aborting action...</b>')
             return None
         self.load_cif_file(self.cif.finalcif_file, current_block, load_changes=False)
-        htmlfile = self.cif.finalcif_file_prefixed(prefix='checkpdf-', suffix='.html')
+        self.pdf_htmlfile = self.cif.finalcif_file_prefixed(prefix='checkpdf-', suffix='.html')
         try:
-            htmlfile.unlink()
+            self.pdf_htmlfile.unlink()
         except (FileNotFoundError, PermissionError):
             pass
         self.ui.CheckCifLogPlainTextEdit.appendPlainText(
             f'Sending pdf report request to {self.options.checkcif_url} ...')
-        self.ckf = CheckCif(parent=self, cif=self.cif, outfile=htmlfile,
+        self.ckf = CheckCif(parent=self, cif=self.cif, outfile=self.pdf_htmlfile,
                             hkl_upload=(not self.ui.structfactCheckBox.isChecked()),
                             pdf=True, url=self.options.checkcif_url,
                             full_iucr=self.ui.fullIucrCheckBox.isChecked(),
@@ -1379,11 +1470,6 @@ class AppWindow(QMainWindow):
         self.ui.CheckcifPDFOnlineButton.setDisabled(True)
         self.ui.CheckcifHTMLOnlineButton.setDisabled(True)
         self.ckf.start()
-        self.ui.CheckCifLogPlainTextEdit.appendPlainText('PDF Checkcif report finished.')
-        try:
-            htmlfile.unlink()
-        except (FileNotFoundError, PermissionError):
-            pass
 
     def do_offline_checkcif(self) -> None:
         self.ui.CheckcifButton.setDisabled(True)
@@ -2342,13 +2428,7 @@ class AppWindow(QMainWindow):
 
     def _calc_grown_atoms(self):
         """Helper to generate the symmetry expanded atoms without drawing them."""
-        atoms_fract = tuple(self.cif.atoms_fract)
-        if not atoms_fract:
-            return []
-
-        sdm = SDM(atoms_fract, self.cif.symmops, self.cif.cell[:6], centric=self.cif.is_centrosymm)
-        needsymm = sdm.calc_sdm()
-        return sdm.packer(sdm, needsymm)
+        return grown_atoms(self.cif)
 
     def get_adps(self) -> dict:
         adp_dict = {}

{finalcif-170 → finalcif-172}/finalcif/cif/checkcif/checkcif.py

@@ -5,13 +5,17 @@
 #  and you think this stuff is worth it, you can buy me a beer in return.
 #  Dr. Daniel Kratzert
 #  ----------------------------------------------------------------------------
+from __future__ import annotations
+
 import re
 import subprocess
 import sys
 import time
+from collections.abc import Callable
 from contextlib import suppress
 from html.parser import HTMLParser
 from pathlib import Path
+from urllib.parse import urljoin
 
 import requests
 from qtpy.QtCore import QThread, Signal
@@ -21,6 +25,189 @@ from requests.exceptions import MissingSchema
 from finalcif.cif.cif_file_io import CifContainer
 from finalcif.cif.vrf_entry import VRFEntry
 from finalcif.gui.dialogs import show_general_warning
+from finalcif.tools.misc import strip_finalcif_of_name
+
+#: Text of the intermediate CheckCIF page that asks for an explicit upload of the
+#: structure factor file.
+STRUCTURE_FACTOR_REQUEST_TEXT = 'File name of structure factor file'
+#: Name of the submit button of the form that continues without structure factors.
+SUBMIT_WITHOUT_HKL_NAME = 'Qsubmitnow'
+#: Maximum difference in seconds between the modification time of a CIF file and a
+#: structure factor file in order to regard them as belonging together.
+MAX_FCF_TIME_DIFFERENCE = 3600.0
+
+
+class HtmlForm:
+    """A single HTML form of the CheckCIF intermediate page."""
+
+    def __init__(self, action: str = '') -> None:
+        self.action = action
+        self.hidden_data: dict[str, str] = {}
+        self.submit_data: dict[str, str] = {}
+        self.file_input_name: str = ''
+
+    @property
+    def payload(self) -> dict[str, str]:
+        return {**self.hidden_data, **self.submit_data}
+
+    def url(self, base_url: str) -> str:
+        return urljoin(base_url, self.action) if self.action else base_url
+
+
+class CheckCifFormParser(HTMLParser):
+    """
+    Extracts the forms of the CheckCIF page that asks for a structure factor upload.
+    """
+
+    def __init__(self, html: str = '') -> None:
+        super().__init__()
+        self.forms: list[HtmlForm] = []
+        self._current_form: HtmlForm | None = None
+        if html:
+            self.feed(html)
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        attrs_dict = {key: value or '' for key, value in attrs}
+        if tag == 'form':
+            self._current_form = HtmlForm(action=attrs_dict.get('action', ''))
+            self.forms.append(self._current_form)
+        elif tag == 'input' and self._current_form is not None:
+            self._add_input(attrs_dict)
+
+    def _add_input(self, attrs_dict: dict[str, str]) -> None:
+        name = attrs_dict.get('name')
+        if not name or self._current_form is None:
+            return
+        input_type = attrs_dict.get('type', '').lower()
+        value = attrs_dict.get('value', '')
+        if input_type == 'hidden':
+            self._current_form.hidden_data[name] = value
+        elif input_type == 'submit':
+            self._current_form.submit_data[name] = value
+        elif input_type == 'file':
+            self._current_form.file_input_name = name
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag == 'form':
+            self._current_form = None
+
+    @property
+    def fcf_upload_form(self) -> HtmlForm | None:
+        """The form with a file input field for the structure factor file."""
+        for form in self.forms:
+            if form.file_input_name:
+                return form
+        return None
+
+    @property
+    def no_structure_factors_form(self) -> HtmlForm | None:
+        """The form that continues the check without the remaining structure factors."""
+        for form in self.forms:
+            if SUBMIT_WITHOUT_HKL_NAME in form.submit_data:
+                return form
+        for form in self.forms:
+            if not form.file_input_name:
+                return form
+        return None
+
+
+def needs_structure_factor_upload(html: str) -> bool:
+    """Whether the CheckCIF server answered with the structure factor upload form."""
+    return STRUCTURE_FACTOR_REQUEST_TEXT in html
+
+
+def _fcf_candidates(cif_file: Path) -> list[Path]:
+    """Possible structure factor files belonging to *cif_file*, without duplicates."""
+    stem_without_finalcif = Path(strip_finalcif_of_name(cif_file.stem, till_name_ends=True)).name
+    names = [f'{cif_file.stem}.fcf', f'{stem_without_finalcif}.fcf']
+    candidates = []
+    for name in names:
+        candidate = cif_file.parent / name
+        if candidate.exists() and candidate not in candidates:
+            candidates.append(candidate)
+    return candidates
+
+
+def _reference_cif_file(cif_file: Path) -> Path:
+    """
+    The CIF file the structure factors should be compared against. This is the file
+    without the '-finalcif' suffix, because that is the file the current CIF was made from.
+    """
+    stem_without_finalcif = Path(strip_finalcif_of_name(cif_file.stem, till_name_ends=True)).name
+    source_cif = cif_file.parent / f'{stem_without_finalcif}.cif'
+    return source_cif if source_cif.exists() else cif_file
+
+
+def find_matching_fcf_file(cif_file: Path,
+                           max_time_difference: float = MAX_FCF_TIME_DIFFERENCE) -> Path | None:
+    """
+    Returns the structure factor file that was created together with *cif_file*.
+
+    Files named like the CIF with and without the '-finalcif' suffix are considered.
+    A file is only accepted if its modification time differs by less than
+    *max_time_difference* seconds from the modification time of the CIF file the
+    current CIF was made from.
+    """
+    reference_file = _reference_cif_file(cif_file)
+    with suppress(OSError):
+        reference_time = reference_file.stat().st_mtime
+        matches = []
+        for candidate in _fcf_candidates(cif_file):
+            difference = abs(candidate.stat().st_mtime - reference_time)
+            if difference < max_time_difference:
+                matches.append((difference, candidate))
+        if matches:
+            return min(matches)[1]
+    return None
+
+
+def _post_form(form: HtmlForm, base_url: str, files: dict | None = None) -> str:
+    response = requests.post(form.url(base_url), data=form.payload, files=files, timeout=900)
+    response.raise_for_status()
+    return response.text
+
+
+def upload_structure_factors(response_html: str, fcf_file: Path, url: str,
+                             progress: Callable[[str], None] = print) -> str:
+    """
+    Answers the structure factor upload form of CheckCIF with *fcf_file*.
+
+    Returns the final report or the unchanged *response_html* if the upload failed.
+    """
+    form = CheckCifFormParser(response_html).fcf_upload_form
+    if form is None:
+        progress('Could not find the structure factor upload form of CheckCIF.')
+        return response_html
+    if not fcf_file.exists():
+        progress(f'Structure factor file {fcf_file.name} not found.')
+        return response_html
+    try:
+        with fcf_file.open('rb') as file_handle:
+            files = {form.file_input_name: (fcf_file.name, file_handle, 'application/octet-stream')}
+            progress(f'Uploading structure factors from {fcf_file.name} ...')
+            html = _post_form(form, url, files=files)
+        progress('Structure factor upload finished.')
+        return html
+    except (OSError, requests.exceptions.RequestException) as e:
+        progress(f'Structure factor upload failed: {e}')
+        return response_html
+
+
+def submit_without_structure_factors(response_html: str, url: str,
+                                     progress: Callable[[str], None] = print) -> str:
+    """
+    Continues a CheckCIF run without the remaining structure factors.
+    """
+    form = CheckCifFormParser(response_html).no_structure_factors_form
+    if form is None:
+        progress('Could not find the CheckCIF form to continue without structure factors.')
+        return response_html
+    try:
+        progress('Requesting the report without the remaining structure factors ...')
+        return _post_form(form, url)
+    except requests.exceptions.RequestException as e:
+        progress(f'Request without structure factors failed: {e}')
+        return response_html
 
 
 class CheckCif(QThread):
@@ -92,10 +279,7 @@ class CheckCif(QThread):
                     print('html checkcif result could not be written.')
                     return
         with suppress(Exception):
-            # parameter missing_ok=True is only available after 3.8
-            Path('finalcif_checkcif_tmp.cif').unlink()
-        if self.pdf:
-            self.finished.connect(self._open_pdf_result)
+            Path('finalcif_checkcif_tmp.cif').unlink(missing_ok=True)
 
     def _do_the_server_request(self, headers: dict, temp_cif: bytes) -> Response | None:
         req = None

{finalcif-170 → finalcif-172}/finalcif/gui/dialogs.py

@@ -19,6 +19,8 @@ from finalcif.tools.selfupdate import ElevationRefused, UpdateCancelled, UpdateE
 
 # Keeps the running downloads alive, a local variable would be garbage collected:
 _running_updates: set = set()
+# The same for a message box without a parent:
+_open_message_boxes: set = set()
 
 
 class InstallerDownload:
@@ -334,7 +336,7 @@ def show_update_warning(parent: QWidget | None, remote_version: int = 0) -> None
                 "https://dkratzert.de/finalcif.html</a>"
     box = QMessageBox(parent)
     box.setTextFormat(QtCore.Qt.TextFormat.AutoText)
-    box.setWindowTitle(" ")
+    box.setWindowTitle("FinalCif update")
     box.setTextInteractionFlags(QtCore.Qt.TextInteractionFlag.TextBrowserInteraction)
     if sys.platform.startswith("win"):
         warn_text += r"<br><br>Updating now will end all running FinalCIF programs!"
@@ -342,7 +344,12 @@ def show_update_warning(parent: QWidget | None, remote_version: int = 0) -> None
         update_button.clicked.connect(lambda: do_update_program(str(remote_version), parent))
     box.setText(warn_text.format(remote_version))
     box.setModal(True)
+    _open_message_boxes.add(box)
+    box.finished.connect(lambda _: _open_message_boxes.discard(box))
     box.show()
+    # The main window is shown right after this box during startup and covers it otherwise:
+    box.raise_()
+    box.activateWindow()
 
 
 def bad_z_message(parent: QWidget | None, z: float) -> None:
@@ -409,6 +416,21 @@ def cif_file_save_dialog(filename: str, parent: QWidget | None = None) -> str:
     return filename
 
 
+def fcf_file_open_dialog(parent: QWidget | None = None, last_dir: str = '', options=None) -> str:
+    """
+    Returns the name of a structure factor file from a file dialog.
+    """
+    file_filter = "Structure factor file (*.fcf)"
+    filename, _ = compat.getopenfilename(parent=parent,
+                                         caption='Select the structure factor (.fcf) file for this CIF',
+                                         basedir=last_dir,
+                                         filters=file_filter,
+                                         selectedfilter=file_filter,
+                                         options=options
+                                         )
+    return filename
+
+
 def video_file_open_dialog(parent: QWidget | None = None, filter: str = "Video file (*.vzs; *.jpg)", last_dir='',
                            options=None) -> str:
     filename, _ = compat.getopenfilename(parent=parent,