finalcif 144__tar.gz → 147__tar.gz

{finalcif-144 → finalcif-147}/.gitignore

@@ -223,3 +223,5 @@ work/~$test.docx
 tests/examples/work/report_cu_BruecknerJK_153F40_0m-finalcif_pm.docx
 tests/examples/multi-multitable.docx
 tests/examples/report_multi-finalcif.docx
+tests/examples/work/cu_BruecknerJK_153F40_0m.lxt
+finalcif_keys_order.cif

{finalcif-144 → finalcif-147}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: finalcif
-Version: 144
+Version: 147
 Summary: CIF file editor
 Project-URL: Homepage, https://dkratzert.de/finalcif.html
 Project-URL: Bug Tracker, https://github.com/dkratzert/FinalCif/issues
@@ -16,10 +16,10 @@ Requires-Dist: certifi
 Requires-Dist: chardet
 Requires-Dist: crossrefapi
 Requires-Dist: docxtpl
-Requires-Dist: gemmi~=0.6
+Requires-Dist: gemmi<0.7.0
 Requires-Dist: html2text
 Requires-Dist: lxml
-Requires-Dist: numpy<2.0
+Requires-Dist: numpy
 Requires-Dist: pefile
 Requires-Dist: pybind11
 Requires-Dist: pyenchant

finalcif-147/finalcif/__init__.py

@@ -0,0 +1,2 @@
+
+VERSION = 147

{finalcif-144 → finalcif-147}/finalcif/appwindow.py

@@ -29,6 +29,7 @@ from finalcif.app_path import application_path
 # QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_ShareOpenGLContexts)
 from finalcif.cif.checkcif.checkcif import MyHTMLParser, AlertHelp, CheckCif
 from finalcif.cif.cif_file_io import CifContainer, GemmiError
+from finalcif.cif import cif_order
 from finalcif.cif.cod.deposit import CODdeposit
 from finalcif.cif.text import utf8_to_str, quote
 from finalcif.datafiles.bruker_data import BrukerData
@@ -61,6 +62,7 @@ from finalcif.tools.platon import PlatonRunner
 from finalcif.tools.settings import FinalCifSettings
 from finalcif.tools.shred import ShredCIF
 from finalcif.tools.space_groups import SpaceGroups
+from finalcif.tools.spgr_format import spgrps
 from finalcif.tools.statusbar import StatusBar
 from finalcif.tools.sumformula import formula_str_to_dict, sum_formula_to_html
 
@@ -104,6 +106,8 @@ class AppWindow(QMainWindow):
         self.status_bar = StatusBar(ui=self.ui)
         self.status_bar.show_message('FinalCif version {}'.format(VERSION))
         self.authors: Union[AuthorLoops, None] = None
+        self.ui.cifOrderWidget.settings = self.settings
+        self.ui.cifOrderWidget.set_order_from_settings(self.settings)
         self.set_window_size_and_position()
         self.ui.cif_main_table.installEventFilter(self)
         # Sorting desynchronized header and columns:
@@ -297,6 +301,14 @@ class AppWindow(QMainWindow):
             self.ui.AddThisAuthorToLoopPushButton.setIcon(qta.icon('mdi.file-table-outline'))
         with suppress(Exception):
             self.ui.DeleteLoopAuthorTemplateButton.setIcon(qta.icon('mdi.delete-forever-outline'))
+        with suppress(Exception):
+            self.ui.cifOrderWidget.ui.deleteKeyPushButton.setIcon(qta.icon('mdi.delete-forever-outline'))
+        with suppress(Exception):
+            self.ui.cifOrderWidget.ui.moveUpPushButton.setIcon(qta.icon('mdi.chevron-up'))
+            self.ui.cifOrderWidget.ui.moveDownPushButton.setIcon(qta.icon('mdi.chevron-down'))
+            self.ui.cifOrderWidget.ui.saveSettingPushButton.setIcon(qta.icon('mdi.content-save'))
+            self.ui.cifOrderWidget.ui.addKeyPushButton.setIcon(qta.icon('mdi.plus'))
+
 
     def connect_signals_and_slots(self) -> None:
         """
@@ -1113,7 +1125,7 @@ class AppWindow(QMainWindow):
         """
         Generates a report document.
         """
-        from finalcif.report.tables import make_report_from, make_multi_tables
+        from finalcif.report.tables import make_multi_tables
         from finalcif.report.templated_report import TemplatedReport
         current_block = self.ui.datanameComboBox.currentIndex()
         if self.cif.doc[current_block].name == 'global':
@@ -1189,6 +1201,10 @@ class AppWindow(QMainWindow):
         with suppress(Exception):
             multitable = self.cif.finalcif_file_prefixed(prefix='', suffix='-multitable.docx')
             arc.zip.write(filename=multitable, arcname=multitable.name)
+        with suppress(Exception):
+            prp_list = self.cif.finalcif_file.parent.glob('*.prp')
+            sorted_prp = sorted(prp_list, key=lambda x: x.stat().st_mtime)
+            arc.zip.write(filename=sorted_prp[-1], arcname=sorted_prp[-1].name)
 
     def open_report_document(self, report_filename: Path, multi_table_document: Path) -> None:
         if self.cif.is_multi_cif:
@@ -1238,10 +1254,12 @@ class AppWindow(QMainWindow):
             self.cif.rename_data_name(''.join(self.ui.datanameComboBox.currentText().split(' ')))
         self.store_data_from_table_rows()
         self.save_ccdc_number()
+        self.cif.set_order_keys(self.ui.cifOrderWidget.order_keys)
         try:
             self.cif.save()
             self.status_bar.show_message(f'  File Saved:  {self.cif.finalcif_file}', 10)
-            print('File saved ...')
+            if DEBUG:
+                print('File saved ...')
             return True
         except Exception as e:
             print('Unable to save file:')
@@ -1473,6 +1491,7 @@ class AppWindow(QMainWindow):
         self.ui.datanameComboBox.blockSignals(False)
         if self.cif.is_multi_cif:
             self._flash_block_combobox()
+        self.cif.set_order_keys(self.ui.cifOrderWidget.order_keys)
         # Enable to find widgets without parent:
         # QtCore.QTimer(self).singleShot(1000, self.find_widgets_without_parent)
 
@@ -1604,8 +1623,9 @@ class AppWindow(QMainWindow):
 
     def fill_space_group_lineedit(self) -> None:
         try:
-            self.ui.Spacegroup_top_LineEdit.setText(
-                SpaceGroups().to_html(self.cif.space_group))
+            txt = (f'<body style="">{SpaceGroups().to_html(self.cif.space_group)} '
+                   f'&thinsp;({spgrps[self.cif.space_group][1].get("itnumber")})</body>')
+            self.ui.Spacegroup_top_LineEdit.setText(txt)
         except Exception as e:
             print('Space group error:', str(e))
             self.ui.Spacegroup_top_LineEdit.setText(self.cif.space_group)
@@ -1910,6 +1930,7 @@ class AppWindow(QMainWindow):
         """
         Adds the cif content to the main table. also add reference to FinalCif.
         """
+        self.cif.set_essential_keys(self.ui.cifOrderWidget.essential_keys)
         for key, value in self.cif.key_value_pairs():
             if not value or value == '?' or value == "'?'":
                 self.missing_data.add(key)

{finalcif-144 → finalcif-147}/finalcif/cif/cif_file_io.py

@@ -16,11 +16,11 @@ from gemmi.cif import as_string, Document, Loop
 from packaging.version import Version
 from shelxfile import Shelxfile
 
-from finalcif.cif.cif_order import order, special_keys
+from finalcif.cif.cif_order import order, special_keys, essential_keys, non_centrosymm_keys
 from finalcif.cif.hkl import HKL, Limit
 from finalcif.cif.text import utf8_to_str, quote, retranslate_delimiter
 from finalcif.datafiles.utils import DSRFind
-from finalcif.tools.misc import essential_keys, non_centrosymm_keys, isnumeric, grouper, strip_finalcif_of_name, \
+from finalcif.tools.misc import isnumeric, grouper, strip_finalcif_of_name, \
     _angstrom_to_x
 
 
@@ -42,7 +42,6 @@ class CifContainer():
                        the existing document is opened.
         """
         self.picometer: bool = False
-        self._hkl_file: str = ''
         self._abs_hkl_details: Dict[str, str] = {}
         if isinstance(file, str):
             self.fileobj = Path(file)
@@ -67,6 +66,16 @@ class CifContainer():
         self.shx = Shelxfile(verbose=True)
         self.shx.read_string(self.res_file_data[1:-1])
         self._on_load()
+        self.order = []
+        self.essential_keys = []
+        self.set_order_keys(order)
+        self.set_essential_keys(essential_keys)
+
+    def set_order_keys(self, keys: List[str]) -> None:
+        self.order = keys
+
+    def set_essential_keys(self, keys: List[str]) -> None:
+        self.essential_keys = keys
 
     @property
     def path_base(self) -> Path:
@@ -139,7 +148,6 @@ class CifContainer():
             self.doc.check_for_duplicates()
         except RuntimeError as e:
             raise GemmiError(e)
-        self.order = order
         self.dsr_used = DSRFind(self.res_file_data).dsr_used
         self.atomic_struct: gemmi.SmallStructure = gemmi.make_small_structure_from_block(self.block)
         # A dictionary to convert Atom names like 'C1_2' or 'Ga3' into Element names like 'C' or 'Ga'
@@ -272,6 +280,8 @@ class CifContainer():
         if self.is_empty():
             print(f'File {filename} is empty.')
             return
+        if not self.is_writable(filename):
+            raise PermissionError(f'Failed to open {filename.resolve()} for writing: Operation not permitted')
         self.order_cif_keys()
         print('Saving CIF to', Path(filename).resolve())
         if Version(gemmi.__version__) > Version('0.6.3'):
@@ -285,6 +295,18 @@ class CifContainer():
         else:
             self.doc.write_file(str(filename), gemmi.cif.Style.Indent35)
 
+    def is_writable(self, filepath: Union[Path, str]) -> bool:
+        filepath = Path(filepath)
+        try:
+            exist = filepath.exists()
+            with open(filepath, 'wb+') as f:
+                f.write(b'')
+            if not exist:
+                Path(filepath).unlink(missing_ok=True)
+            return True
+        except Exception:
+            return False
+
     def order_cif_keys(self) -> None:
         """
         Brings the current CIF in the specific order of the order list.
@@ -324,14 +346,10 @@ class CifContainer():
     def hkl_file(self) -> str:
         hkl_loop: Loop = self.get_loop('_diffrn_refln_index_h')
         if hkl_loop and hkl_loop.width() > 4:
-            if not self._hkl_file:
-                self._hkl_file = self._hkl_from_cif_format(hkl_loop)
-            return self._hkl_file
+            return self._hkl_from_cif_format(hkl_loop)
         else:
             # returns an empty string if no cif hkl was found:
-            if not self._hkl_file:
-                self._hkl_file = self._hkl_from_shelx()
-            return self._hkl_file
+            return self._hkl_from_shelx()
 
     def _hkl_from_cif_format(self, hkl_loop: Loop) -> str:
         hkl_list = []
@@ -377,7 +395,7 @@ class CifContainer():
         return HKL(self.hkl_file, self.block.name, hklf_type=self.hklf_number).get_hkl_min_max()
 
     def _hklf_number_from_shelxl_file(self) -> int:
-        if self.shx.hklf:
+        if self.shx and self.shx.hklf:
             return self.shx.hklf.n if self.shx.hklf.n != 0 else 4
         else:
             return 4
@@ -501,8 +519,11 @@ class CifContainer():
 
     def add_loop_from_columns(self, loop_tags: List[str],
                               column_values: Union[List[List[str]], Tuple[Tuple[str]]]) -> gemmi.cif.Loop:
-        gemmi_loop = self.init_loop(loop_tags)
-        gemmi_loop.set_all_values(column_values)
+        try:
+            gemmi_loop = self.init_loop(loop_tags)
+            gemmi_loop.set_all_values(column_values)
+        except RuntimeError as err:
+            raise Exception('Gemmi raised an exception') from err
         return gemmi_loop
 
     @property
@@ -829,7 +850,7 @@ class CifContainer():
         publ_loop = self.block.find_loop('_geom_angle_publ_flag')
         angle = namedtuple('angle', ('label1', 'label2', 'label3', 'angle_val', 'symm1', 'symm2'))
         for label1, label2, label3, angle_val, symm1, symm2, publ in \
-                zip(label1, label2, label3, angle_val, symm1, symm2, publ_loop):
+            zip(label1, label2, label3, angle_val, symm1, symm2, publ_loop):
             if (without_H and (self.ishydrogen(label1) or self.ishydrogen(label2) or
                                self.ishydrogen(label3)) or (self.yes_not_set(publ))):
                 continue
@@ -901,7 +922,7 @@ class CifContainer():
         hydr = namedtuple('HydrogenBond', ('label_d', 'label_h', 'label_a', 'dist_dh', 'dist_ha', 'dist_da',
                                            'angle_dha', 'symm'))
         for label_d, label_h, label_a, dist_dh, dist_ha, dist_da, angle_dha, symm, publ in (
-                zip(label_d, label_h, label_a, dist_dh, dist_ha, dist_da, angle_dha, symm, publ_loop)):
+            zip(label_d, label_h, label_a, dist_dh, dist_ha, dist_da, angle_dha, symm, publ_loop)):
             if self.yes_not_set(publ):
                 continue
             if self.picometer:
@@ -957,7 +978,7 @@ class CifContainer():
         """
         Check if there are keys not in the cif but in essential_keys and append them if so.
         """
-        for key in essential_keys:
+        for key in self.essential_keys:
             if key not in all_keys:
                 if self._is_centrokey(key):
                     continue

{finalcif-144 → finalcif-147}/finalcif/cif/cif_order.py

@@ -212,6 +212,8 @@ order = [
     '_diffrn_radiation_monochromator',
     '_diffrn_radiation_polarisn_norm',
     '_diffrn_radiation_collimation',
+    '_bruker_diffrn_measurement_temperature_device',
+    '_bruker_diffrn_measurement_temperature_device_make',
     '_olex2_diffrn_ambient_temperature_device',
     '_diffrn_measurement_ambient_temperature_device_make',
     '_diffrn_radiation_probe',
@@ -361,3 +363,129 @@ order = [
     '_bruker_diffrn_runs_theta',
     '_bruker_diffrn_runs_distance',
 ]
+
+
+# These keywords will end up in the CIF in any case:
+essential_keys = (
+    # '_atom_sites_solution_secondary'
+    # '_diffrn_measurement_specimen_adhesive'
+    # '_diffrn_source_power'
+    # '_diffrn_source_target'
+    # '_olex2_diffrn_ambient_temperature_device'
+    '_diffrn_measurement_ambient_temperature_device_make',
+    '_atom_sites_solution_hydrogens',
+    '_atom_sites_solution_primary',
+    # '_audit_contact_author_name',
+    # '_audit_contact_author_address',
+    # '_audit_contact_author_email',
+    # '_audit_contact_author_phone',
+    '_audit_creation_method',
+    '_publ_section_references',
+    '_cell_angle_alpha',
+    '_cell_angle_beta',
+    '_cell_angle_gamma',
+    '_cell_formula_units_Z',
+    '_cell_length_a',
+    '_cell_length_b',
+    '_cell_length_c',
+    '_cell_measurement_reflns_used',
+    '_cell_measurement_temperature',
+    '_cell_measurement_theta_max',
+    '_cell_measurement_theta_min',
+    '_cell_volume',
+    '_chemical_absolute_configuration',
+    '_chemical_formula_moiety',
+    '_chemical_formula_sum',
+    '_chemical_formula_weight',
+    '_chemical_melting_point',
+    '_chemical_name_common',
+    '_chemical_name_systematic',
+    '_computing_cell_refinement',
+    '_computing_data_collection',
+    '_computing_data_reduction',
+    '_computing_molecular_graphics',
+    # '_computing_publication_material',
+    '_computing_structure_refinement',
+    '_computing_structure_solution',
+    # '_diffrn_ambient_environment',
+    '_diffrn_ambient_temperature',
+    '_diffrn_detector',
+    '_diffrn_detector_area_resol_mean',
+    '_diffrn_detector_type',
+    '_diffrn_measured_fraction_theta_full',
+    '_diffrn_measured_fraction_theta_max',
+    '_diffrn_measurement_device',
+    '_diffrn_measurement_device_type',
+    '_diffrn_measurement_method',
+    '_diffrn_measurement_specimen_support',
+    '_diffrn_radiation_monochromator',
+    '_diffrn_radiation_probe',
+    '_diffrn_radiation_type',
+    '_diffrn_radiation_wavelength',
+    '_diffrn_reflns_Laue_measured_fraction_full',
+    '_diffrn_reflns_Laue_measured_fraction_max',
+    '_diffrn_reflns_av_R_equivalents',
+    '_diffrn_reflns_av_unetI/netI',
+    '_diffrn_reflns_number',
+    '_diffrn_reflns_point_group_measured_fraction_full',
+    '_diffrn_reflns_point_group_measured_fraction_max',
+    '_diffrn_reflns_theta_full',
+    '_diffrn_reflns_theta_max',
+    '_diffrn_reflns_theta_min',
+    '_diffrn_source',
+    '_diffrn_source_current',
+    '_diffrn_source_type',
+    '_diffrn_source_voltage',
+    '_exptl_absorpt_coefficient_mu',
+    '_exptl_absorpt_correction_T_max',
+    '_exptl_absorpt_correction_T_min',
+    '_exptl_absorpt_correction_type',
+    '_exptl_absorpt_process_details',
+    '_exptl_crystal_F_000',
+    '_exptl_crystal_colour',
+    '_exptl_crystal_density_diffrn',
+    '_exptl_crystal_density_meas',
+    '_exptl_crystal_density_method',
+    '_exptl_crystal_description',
+    '_exptl_crystal_recrystallization_method',
+    '_exptl_crystal_size_max',
+    '_exptl_crystal_size_mid',
+    '_exptl_crystal_size_min',
+    '_exptl_special_details',
+    '_geom_special_details',
+    '_refine_ls_R_factor_all',
+    '_refine_ls_R_factor_gt',
+    '_refine_ls_abs_structure_Flack',
+    '_refine_ls_abs_structure_details',
+    '_refine_ls_extinction_coef',
+    '_refine_ls_extinction_method',
+    '_refine_ls_goodness_of_fit_ref',
+    '_refine_ls_hydrogen_treatment',
+    '_refine_ls_matrix_type',
+    '_refine_ls_number_parameters',
+    '_refine_ls_number_reflns',
+    '_refine_ls_number_restraints',
+    '_refine_ls_restrained_S_all',
+    '_refine_ls_shift/su_max',
+    '_refine_ls_shift/su_mean',
+    '_refine_ls_structure_factor_coef',
+    '_refine_ls_wR_factor_gt',
+    '_refine_ls_wR_factor_ref',
+    '_refine_ls_weighting_details',
+    '_refine_ls_weighting_scheme',
+    '_refine_special_details',
+    '_reflns_Friedel_coverage',
+    '_reflns_Friedel_fraction_full',
+    '_reflns_Friedel_fraction_max',
+    '_reflns_number_gt',
+    '_reflns_number_total',
+    '_reflns_special_details',
+    '_reflns_threshold_expression',
+    '_space_group_IT_number',
+    '_space_group_crystal_system',
+    '_space_group_name_H-M_alt',
+    '_space_group_name_Hall',
+    # '_space_group_symop_operation_xyz'
+)
+non_centrosymm_keys = ('_chemical_absolute_configuration', '_refine_ls_abs_structure_Flack',
+                       '_refine_ls_abs_structure_details')

finalcif-147/finalcif/ciforder/order.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+import enum
+import sys
+from pathlib import Path
+from typing import List, TYPE_CHECKING
+
+import gemmi
+from PyQt5 import QtWidgets, QtCore
+
+from finalcif.cif import cif_order
+from finalcif.ciforder.order_ui import Ui_CifOrderForm
+from finalcif.gui import dialogs
+from finalcif.gui.custom_classes import CifOrderItem
+from finalcif.gui.dialogs import cif_file_save_dialog, show_general_warning
+from finalcif.gui.new_key_dialog import NewKey
+
+if TYPE_CHECKING:
+    from finalcif.tools.settings import FinalCifSettings
+
+
+class Column(enum.IntEnum):
+    key = 0
+
+
+class CifOrder(QtWidgets.QGroupBox):
+    def __init__(self, parent=None, cif_file: Path = None):
+        super().__init__(parent)
+        self.ui = Ui_CifOrderForm()
+        self.ui.setupUi(self)
+        self.cif = None
+        self.settings = None
+        self.essential_keys = cif_order.essential_keys
+        self.set_keys(cif_order.order)
+        if cif_file is not None:
+            self.set_keys_from_cif(cif_file)
+        self.connect_signals_and_slots()
+
+    def set_order_from_settings(self, settings: FinalCifSettings = None):
+        self.settings = settings
+        if settings is not None:
+            order = settings.load_settings_list('cif_order', 'order')
+            essentials = settings.load_settings_list('cif_order', 'essentials')
+            if order:
+                self.essential_keys = essentials
+                self.set_keys(order)
+
+    def connect_signals_and_slots(self):
+        self.ui.importCifPushButton.clicked.connect(self.import_cif)
+        self.ui.restoreDefaultPushButton.clicked.connect(self.restore_default)
+        self.ui.addKeyPushButton.clicked.connect(self.open_add_cif_key)
+        self.ui.saveSettingPushButton.clicked.connect(self.save_setting)
+        self.ui.deleteKeyPushButton.clicked.connect(self.delete_keys)
+        self.ui.exportToCifPushButton.clicked.connect(self.export_cif)
+        # Connect signals for moveUpPushButton
+        self.ui.moveUpPushButton.pressed.connect(lambda: self.start_repeated_action(self.move_row_up))
+        self.ui.moveUpPushButton.released.connect(self.stop_repeated_action)
+        # Connect signals for moveDownPushButton
+        self.ui.moveDownPushButton.pressed.connect(lambda: self.start_repeated_action(self.move_row_down))
+        self.ui.moveDownPushButton.released.connect(self.stop_repeated_action)
+        # Timer for repeated actions
+        self.timer = QtCore.QTimer(self)
+        self.timer.setInterval(170)
+        self.timer.timeout.connect(self.perform_repeated_action)
+        self.current_action = None
+
+    def start_repeated_action(self, action):
+        """Start the timer with the given action."""
+        self.current_action = action
+        action()  # Perform the action immediately
+        self.timer.start()
+
+    def stop_repeated_action(self):
+        """Stop the timer and reset the current action."""
+        self.timer.stop()
+        self.current_action = None
+
+    def perform_repeated_action(self):
+        """Perform the currently set action."""
+        if self.current_action:
+            self.current_action()
+
+    def move_row_up(self):
+        current_row = self.ui.cifOrderTableWidget.currentRow()
+        if current_row > 0:
+            self.swap_rows(current_row, current_row - 1)
+            self.ui.cifOrderTableWidget.setCurrentCell(current_row - 1, Column.key)
+
+    def move_row_down(self):
+        table = self.ui.cifOrderTableWidget
+        current_row = table.currentRow()
+        if current_row < table.rowCount() - 1:
+            self.swap_rows(current_row, current_row + 1)
+            table.setCurrentCell(current_row + 1, Column.key)
+
+    def swap_rows(self, row1, row2):
+        table = self.ui.cifOrderTableWidget
+        item1 = table.item(row1, Column.key)
+        item2 = table.item(row2, Column.key)
+        if item1 and item2:
+            text1 = item1.text()
+            text2 = item2.text()
+            check_state1 = item1.checkState()
+            check_state2 = item2.checkState()
+            item1.setText(text2)
+            item1.setCheckState(check_state2)
+            item2.setText(text1)
+            item2.setCheckState(check_state1)
+
+    @property
+    def order_keys(self):
+        keys = []
+        for row in range(self.ui.cifOrderTableWidget.rowCount()):
+            key = self.ui.cifOrderTableWidget.item(row, Column.key).text()
+            keys.append(key)
+        return keys
+
+    @property
+    def order_essentials(self):
+        essentials = []
+        for row in range(self.ui.cifOrderTableWidget.rowCount()):
+            item = self.ui.cifOrderTableWidget.item(row, Column.key)
+            essential = item.checkState()
+            if essential:
+                essentials.append(item.text())
+        return essentials
+
+    def set_keys_from_cif(self, cif_file) -> None:
+        try:
+            self.cif = gemmi.cif.read_file(cif_file)
+            block = self.cif.sole_block()
+        except Exception:
+            show_general_warning(self, 'Unable to load file')
+            return
+        keys = [x.pair[0] for x in block if x.pair is not None]
+        essentials = [x.pair[0] for x in block if x.pair is not None and x.pair[1] == 'True']
+        self.set_essentials(essentials)
+        self.set_keys(keys)
+
+    def set_essentials(self, essentials):
+        self.essential_keys = essentials
+
+    def set_keys(self, order_keys: List[str] = None):
+        self.ui.cifOrderTableWidget.setRowCount(0)
+        row = 0
+        for key_text in order_keys:
+            if not key_text:
+                continue
+            self.ui.cifOrderTableWidget.insertRow(row)
+            self.set_row_text(key_text, row)
+            row += 1
+        # self.ui.cifOrderTableWidget.resizeColumnsToContents()
+
+    def set_row_text(self, key_text: str, row: int) -> None:
+        item1 = CifOrderItem(key_text)
+        item1.setFlags(item1.flags() | QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled)
+        item1.setText(key_text)
+        if key_text in self.essential_keys:
+            item1.setEssential(True)
+        else:
+            item1.setEssential(False)
+        self.ui.cifOrderTableWidget.setItem(row, Column.key, item1)
+
+    def set_keys_from_settings(self, keys: List[str]):
+        self.set_keys(keys)
+
+    def import_cif(self):
+        cif_file = dialogs.cif_file_open_dialog()
+        if self._file_is_there(cif_file):
+            self.set_keys_from_cif(cif_file)
+
+    def _file_is_there(self, cif_file: str) -> bool:
+        return cif_file is not None and Path(cif_file).is_file() and Path(cif_file).exists()
+
+    def restore_default(self):
+        self.essential_keys = cif_order.essential_keys
+        self.settings.save_settings_list('cif_order', 'order', [])
+        self.settings.save_settings_list('cif_order', 'essentials', [])
+        self.set_keys(cif_order.order)
+
+    def open_add_cif_key(self):
+        new_key = NewKey(self)
+        new_key.show()
+        new_key.new_key_added.connect(self.add_key)
+
+    def add_key(self, key: str) -> None:
+        if key not in self.order_keys:
+            self.ui.cifOrderTableWidget.insertRow(0)
+            self.set_row_text(key, 0)
+
+    def save_setting(self):
+        self.settings.save_settings_list('cif_order', 'order', self.order_keys)
+        self.settings.save_settings_list('cif_order', 'essentials', self.order_essentials)
+        self.essential_keys = self.order_essentials
+
+    def delete_keys(self):
+        items = self.ui.cifOrderTableWidget.selectedItems()
+        for item in items:
+            self.ui.cifOrderTableWidget.removeRow(item.row())
+
+    def export_cif(self):
+        doc = gemmi.cif.Document()
+        blockname = 'FinalCif_keys_order'
+        block = doc.add_new_block(blockname)
+        for key in self.order_keys:
+            value = 'True' if key in self.order_essentials else 'False'
+            block.set_pair(key, value)
+        filename = cif_file_save_dialog(blockname.lower() + '.cif')
+        if not filename.strip():
+            return
+        try:
+            doc.write_file(filename, style=gemmi.cif.Style.Indent35)
+        except PermissionError:
+            if Path(filename).is_dir():
+                return
+            show_general_warning(self, 'No permission to write file to {}'.format(Path(filename).resolve()))
+
+
+if __name__ == "__main__":
+    from finalcif.tools.settings import FinalCifSettings
+
+    app = QtWidgets.QApplication(sys.argv)
+    # form = CifOrder(parent=None, cif_file=Path('test-data/1000007.cif').resolve())
+    settings = FinalCifSettings()
+    form = CifOrder(parent=None)
+    form.set_order_from_settings(settings)
+    form.show()
+    form.raise_()
+    sys.exit(app.exec_())