digichem-core 7.2.0__py3-none-any.whl → 7.3.0__py3-none-any.whl

digichem/__init__.py

@@ -11,7 +11,7 @@ from digichem.datas import get_resource
 ####################
 
 
-__version__ = "7.2.0"
+__version__ = "7.3.0"
 _v_parts = __version__.split("-")[0].split(".")
 major_version = int(_v_parts[0])
 minor_version = int(_v_parts[1])
@@ -30,7 +30,7 @@ __author__ = [
 ]
 
 # Program date (when we were last updated). This is changed automatically.
-_last_updated_string = "18/12/2025"
+_last_updated_string = "02/02/2026"
 last_updated = datetime.strptime(_last_updated_string, "%d/%m/%Y")
 
 # The sys attribute 'frozen' is our flag, '_MEIPASS' is the dir location.

digichem/datas.py

@@ -1,8 +1,12 @@
 import atexit
 from contextlib import ExitStack
 
-# TODO: Can switch to non-backport importlib.resources once >= 3.9
-import importlib_resources
+try:
+    import importlib.resources
+    importlib_resources = importlib.resources
+
+except ImportError:
+    import importlib_resources
 
 def get_resource(name):
     """

digichem/image/render.py

@@ -68,7 +68,8 @@ class Render_maker(File_converter, Cropable_mixin):
         self.target_resolution = resolution
         self.also_make_png = also_make_png
         self.isovalue = isovalue
-        self.num_cpu = num_cpu
+        # TODO: Should we not guess the number of CPUs required?
+        self.num_cpu = num_cpu if num_cpu is not None else num_cpu
         
         # TODO: These.
         self.primary_colour = "red"

digichem/input/__init__.py

@@ -1,3 +1,3 @@
 from .base import Input_file
 from .gaussian import Gaussian_input_parser
-from .digichem_input import Digichem_coords_ABC, Digichem_coords, si_from_yaml, si_from_file, si_from_data
+from .digichem_input import Digichem_coords_ABC, Digichem_coords, si_from_yaml, si_from_file, si_from_data, si_iter_from_xyz

digichem/input/digichem_input.py

@@ -502,4 +502,36 @@ def si_from_file(file_name, file_type = None, *, gen3D = None, **kwargs):
             
         except:
             raise ValueError("Could not parse coordinates from '{}'".format(file_name))
-    
+    
+
+def si_iter_from_xyz(file_name, **kwargs):
+    """
+    Return a generator that yields Digichem_coords objects from the molecules in an xyz file.
+    
+    :param file_name: The XYZ file to read from. If the file contains multiple structures, they will be read in sequence.
+    """
+    with open(file_name, "rt") as file:
+        # How many lines are we expecting in the current molecule.
+        doc_length = None
+        doc_line_no = 0
+        data = []
+
+        for line in file:
+            if doc_length is None:
+                # New document, how big is it?
+                doc_length = int(line.strip()) +2
+
+            # What line of the document are we on right now?
+            doc_line_no += 1
+            data.append(line)
+
+            # Are we still reading the same document?
+            if doc_line_no >= doc_length:
+                # End of the document, we got a molecule!
+                yield Digichem_coords_v2.from_xyz("".join(data), **kwargs)
+
+                # Time for a new document, reset.
+                doc_length = None
+                doc_line_no = 0
+                data = []
+            

digichem/misc/io.py

@@ -322,12 +322,17 @@ class Safe_path():
         # Close our file.
         self.close()
 
-def dir_size(target):
+def dir_size(target, apparent = False):
     """
     Calculate the total used file space of a directory and all contents.
     """
     bytes = 0
-    for path in itertools.chain(Path(target).rglob("*"), [Path(target)]):
-        bytes += path.stat().st_size
+    for path in itertools.chain(Path(target).glob('**/*'), [Path(target)]):
+        stat = path.stat()
+        if not apparent and hasattr(stat, "st_blocks"):
+            bytes += stat.st_blocks * 512
+        
+        else:
+            bytes += stat.st_size
     
     return bytes

digichem/parse/base.py

@@ -2,6 +2,10 @@
 from pathlib import Path
 import pwd
 import os
+import csv
+import numpy
+import math
+from scipy import signal
 
 from digichem.exception.base import Digichem_exception
 from digichem.result.orbital import Molecular_orbital_list,\
@@ -19,6 +23,7 @@ from digichem.result.vibration import Vibrations_list
 from digichem.result.emission import Relaxed_excited_state
 from digichem.result.nmr import NMR_shielding, NMR_spin_couplings_list, NMR_list
 from digichem.result.alignment.base import Minimal, Alignment
+import digichem.log
 
 
 # NOTE: This is a repeat of the list in util to avoid circular import nonsense.
@@ -32,7 +37,7 @@ custom_parsing_formats = [
 class Parser_abc():
     """ABC for all parsers."""
 
-    def __init__(self, *, raw_data = None, options, metadata_defaults = None, **kwargs):
+    def __init__(self, *, raw_data = None, options, metadata_defaults = None, profile_file = None, **kwargs):
         """
         Top level constructor for calculation parsers.
         """
@@ -48,6 +53,9 @@ class Parser_abc():
         # Manually provided overrides.
         self.metadata_defaults = metadata_defaults if metadata_defaults is not None else {}
         
+        # Save the profiling file.
+        self.profile_file = profile_file
+        
         # Parse (if we haven't already).
         try:
             if self.data is None:
@@ -110,6 +118,121 @@ class Parser_abc():
         metadata = self.metadata_defaults.copy()
         metadata.update(self.data.metadata)
         self.data.metadata = metadata
+
+        # Add profiling data.
+        try:
+            self.parse_profile_file()
+        
+        except Exception:
+            if self.profile_file and self.profile_file.exists():
+                digichem.log.get_logger().warning("Could not parse profile.csv file; profiling data will be unavailable", exc_info=True)
+            
+            else:
+                pass
+    
+    def parse_profile_file(self):
+        """
+        """
+        # Real calculations can end up with millions of rows, which is far too much data to handle.
+        # We will need to downsample if we have too many data points.
+        # First work out how many rows there are.
+        try:
+            with open(self.profile_file, "rb") as profile_file:
+                lines = sum(1 for _ in profile_file) -1 # Remove 1 line for the header.
+        
+        except FileNotFoundError:
+            # This is ok
+            return
+
+        if lines < 2:
+            return
+
+        max_lines  = self.options.parse['profiling_rows']
+        factor = math.ceil(lines / max_lines)
+        
+        with open(self.profile_file) as profile_file:
+            reader = csv.reader(profile_file)
+
+            # Get the header.
+            headers = next(reader)
+
+            # Check headers match.
+            if (headers[0] == "Duration / s" and 
+               headers[1] == "Memory Used (Real) / bytes" and
+               headers[2] == "Memory Used (Real) / %" and
+               headers[3] == "Memory Available  (Real) / bytes" and
+               headers[4] == "Memory Available (Real) / %" and
+               headers[9] == "CPU Usage / %" and
+               headers[15] == "Output Directory Available / bytes" and
+               headers[17] == "Scratch Directory Used / bytes" and
+               headers[18] == "Scratch Directory Available / bytes"
+            ):
+                column_map = {
+                    "duration": 0,
+                    "memory_used": 1,
+                    "memory_used_percent": 2,
+                    "memory_available": 3,
+                    "memory_available_percent": 4,
+                    "cpu_used": 9,
+                    "output_available": 15,
+                    "scratch_used": 17,
+                    "scratch_available": 18
+                }
+            
+            elif (headers[0] == "Duration / s" and 
+               headers[1] == "Memory Used (Real) / bytes" and
+               headers[2] == "Memory Used (Real) / %" and
+               headers[3] == "Memory Available  (Real) / bytes" and
+               headers[4] == "Memory Available (Real) / %" and
+               headers[9] == "CPU Usage / %" and
+               headers[15] == "Output Directory Available / bytes" and
+               headers[17] == "Scratch Directory Available / bytes"
+            ):
+                column_map = {
+                    "duration": 0,
+                    "memory_used": 1,
+                    "memory_used_percent": 2,
+                    "memory_available": 3,
+                    "memory_available_percent": 4,
+                    "cpu_used": 9,
+                    "output_available": 15,
+                    "scratch_available": 17
+                }
+            
+            else:
+                raise Digichem_exception("wrong headers found in profile.csv file")
+            
+            # Then the body.
+            # TODO: Reading the entire file is not ideal...
+            data = numpy.genfromtxt(
+                profile_file,
+                delimiter=',',
+                # TODO: use something better.
+                filling_values = "0"
+            )
+
+        # We'll keep:
+        # - duration
+        # - memory used
+        # - memory used %
+        # - memory available
+        # - memory available %
+        # - cpu used
+        # - output space
+        # - scratch space
+        new_data = numpy.zeros((math.ceil(lines / factor), len(column_map)))
+
+        # Now decimate.
+        for i, k in enumerate(column_map.values()):
+            if factor > 1:
+                new_data[:, i] = signal.decimate(data[:, k], factor)
+            else:
+                new_data[:, i] = data[:, k]
+        
+        
+        self.data.metadata['performance'] = {
+            key: new_data[:, index] for index, key in enumerate(column_map)
+        }
             
     def process_all(self):
         """
@@ -197,7 +320,7 @@ class File_parser_abc(Parser_abc):
         """
         # Set our name.
         self.log_file_paths = self.sort_log_files([Path(log_file) for log_file in log_files if log_file is not None])
-        
+
         # Panic if we have no logs.
         if len(self.log_file_paths) == 0:
             raise Digichem_exception("Cannot parse calculation output; no available log files. Are you sure the given path is a log file or directory containing log files?")

digichem/parse/cclib.py

@@ -1,9 +1,5 @@
 from pathlib import Path
 import itertools
-import csv
-import numpy
-import math
-from scipy import signal
 
 import digichem.log
 from digichem.parse.base import File_parser_abc
@@ -31,12 +27,8 @@ class Cclib_parser(File_parser_abc):
         """
         # Also save our aux files, stripping None.
         self.auxiliary_files = {name: aux_file for name,aux_file in auxiliary_files.items() if aux_file is not None}
-
-        # TODO: Does this belong here?
-        # Also have a look for a profile.csv file that we can us for performance metrics.
-        self.profile_file = Path(log_files[0].parent, "../Logs/profile.csv")
         
-        super().__init__(*log_files, options = options, metadata_defaults = metadata_defaults)
+        super().__init__(*log_files, options = options, metadata_defaults = metadata_defaults, profile_file = Path(log_files[0].parent, "../Logs/profile.csv"))
         
     @classmethod
     def from_logs(self, *log_files, hints = None, options, **kwargs):
@@ -132,111 +124,6 @@ class Cclib_parser(File_parser_abc):
             
             else:
                 pass
-
-    def parse_profile_file(self):
-        """
-        """
-        # Real calculations can end up with millions of rows, which is far too much data to handle.
-        # We will need to downsample if we have too many data points.
-        # First work out how many rows there are.
-        try:
-            with open(self.profile_file, "rb") as profile_file:
-                lines = sum(1 for _ in profile_file) -1 # Remove 1 line for the header.
-        
-        except FileNotFoundError:
-            # This is ok
-            return
-
-        if lines < 2:
-            return
-
-        max_lines  = self.options.parse['profiling_rows']
-        factor = math.ceil(lines / max_lines)
-        
-        with open(self.profile_file) as profile_file:
-            reader = csv.reader(profile_file)
-
-            # Get the header.
-            headers = next(reader)
-
-            # Check headers match.
-            if (headers[0] == "Duration / s" and 
-               headers[1] == "Memory Used (Real) / bytes" and
-               headers[2] == "Memory Used (Real) / %" and
-               headers[3] == "Memory Available  (Real) / bytes" and
-               headers[4] == "Memory Available (Real) / %" and
-               headers[9] == "CPU Usage / %" and
-               headers[15] == "Output Directory Available / bytes" and
-               headers[17] == "Scratch Directory Used / bytes" and
-               headers[18] == "Scratch Directory Available / bytes"
-            ):
-                column_map = {
-                    "duration": 0,
-                    "memory_used": 1,
-                    "memory_used_percent": 2,
-                    "memory_available": 3,
-                    "memory_available_percent": 4,
-                    "cpu_used": 9,
-                    "output_available": 15,
-                    "scratch_used": 17,
-                    "scratch_available": 18
-                }
-            
-            elif (headers[0] == "Duration / s" and 
-               headers[1] == "Memory Used (Real) / bytes" and
-               headers[2] == "Memory Used (Real) / %" and
-               headers[3] == "Memory Available  (Real) / bytes" and
-               headers[4] == "Memory Available (Real) / %" and
-               headers[9] == "CPU Usage / %" and
-               headers[15] == "Output Directory Available / bytes" and
-               headers[17] == "Scratch Directory Available / bytes"
-            ):
-                column_map = {
-                    "duration": 0,
-                    "memory_used": 1,
-                    "memory_used_percent": 2,
-                    "memory_available": 3,
-                    "memory_available_percent": 4,
-                    "cpu_used": 9,
-                    "output_available": 15,
-                    "scratch_available": 17
-                }
-            
-            else:
-                raise Digichem_exception("wrong headers found in profile.csv file")
-            
-            # Then the body.
-            # TODO: Reading the entire file is not ideal...
-            data = numpy.genfromtxt(
-                profile_file,
-                delimiter=',',
-                # TODO: use something better.
-                filling_values = "0"
-            )
-
-        # We'll keep:
-        # - duration
-        # - memory used
-        # - memory used %
-        # - memory available
-        # - memory available %
-        # - cpu used
-        # - output space
-        # - scratch space
-        new_data = numpy.zeros((math.ceil(lines / factor), len(column_map)))
-
-        # Now decimate.
-        for i, k in enumerate(column_map.values()):
-            if factor > 1:
-                new_data[:, i] = signal.decimate(data[:, k], factor)
-            else:
-                new_data[:, i] = data[:, k]
-        
-        
-        self.data.metadata['performance'] = {
-            key: new_data[:, index] for index, key in enumerate(column_map)
-        }
-        
         
     def parse_output_line(self, log_file, line):
         """

digichem/parse/censo.py

@@ -0,0 +1,135 @@
+import hashlib
+import json
+import datetime
+import periodictable
+from uuid import uuid4
+import types
+
+from digichem.parse.base import Parser_abc
+import digichem.log
+from digichem.input.digichem_input import si_from_file
+
+
+class Censo_parser(Parser_abc):
+    """
+    Top level class for parsing output from censo data.
+    """
+
+    def __init__(self, mol_name, program, **kwargs):
+        self.program = program
+        self.mol_name = mol_name
+        super().__init__(**kwargs)
+
+    def _parse(self):
+        """
+        Extract results from our output files.
+        """
+        self.data = types.SimpleNamespace()
+
+        # Censo calculations are normally made up of four distinct phases (prescreening, screening, optimisation, and refinement).
+        calculations = []
+        methods = []
+        functional = []
+        basis_set = []
+        engines = []
+
+        if self.program.calculation.properties['prescreening']['calc']:
+            calculations.append("Screening")
+            methods.append(self.program.calculation.properties['prescreening']['gfn'])
+            methods.append("DFT")
+            engines.append(self.program.calculation.properties['prescreening']['engine'])
+            functional.append(self.program.calculation.properties['prescreening']['functional'])
+            basis_set.append(self.program.calculation.properties['prescreening']['basis_set'])
+        
+        if self.program.calculation.properties['screening']['calc']:
+            calculations.append("Screening")
+            methods.append(self.program.calculation.properties['screening']['gfn'])
+            methods.append("DFT")
+            engines.append(self.program.calculation.properties['screening']['engine'])
+            functional.append(self.program.calculation.properties['screening']['functional'])
+            basis_set.append(self.program.calculation.properties['screening']['basis_set'])
+        
+        if self.program.calculation.properties['optimisation']['calc']:
+            calculations.append("Optimisation")
+            methods.append(self.program.calculation.properties['optimisation']['gfn'])
+            methods.append("DFT")
+            engines.append(self.program.calculation.properties['optimisation']['engine'])
+            functional.append(self.program.calculation.properties['optimisation']['functional'])
+            basis_set.append(self.program.calculation.properties['optimisation']['basis_set'])
+        
+        if self.program.calculation.properties['refinement']['calc']:
+            calculations.append("Single Point")
+            methods.append(self.program.calculation.properties['refinement']['gfn'])
+            methods.append("DFT")
+            engines.append(self.program.calculation.properties['refinement']['engine'])
+            functional.append(self.program.calculation.properties['refinement']['functional'])
+            basis_set.append(self.program.calculation.properties['refinement']['basis_set'])
+
+        engines = ["CENSO"] + list(set(engines))
+
+        # Metadata we can get entirely from our passed in program object.
+        self.data.metadata = {
+            "name": self.mol_name,
+            "jobId": self.program.calculation.job_id,
+            "wall_time": [self.program.duration],
+            "cpu_time": [self.program.duration * self.program.calculation.performance['num_cpu']],
+            "date": datetime.datetime.now(datetime.timezone.utc).timestamp(),
+            "package": "/".join(engines),
+            #"package_version": None,
+            "calculations": calculations,
+            "success": not self.program.error,
+            "methods": methods,
+            "functional": "/".join(functional),
+            "basis_set": "/".join(basis_set),
+            "charge": self.program.calculation.charge,
+            "multiplicity": self.program.calculation.multiplicity,
+            "optimisation_converged": not self.program.error,
+            #"temperature": None,
+            #"pressure": None,
+            "orbital_spin_type": "restricted" if self.program.calculation.multiplicity == 1 else "unrestricted",
+            "solvent_name": str(self.program.calculation.solution['solvent']) if self.program.calculation.solution['calc'] else None,
+            "solvent_model": self.program.calculation.solution['model'] if self.program.calculation.solution['calc'] else None,
+            "num_cpu": self.program.calculation.performance['num_cpu'],
+            #"memory_used": None,
+            "memory_available": self.program.calculation.performance['memory'],
+        }
+
+        try:
+            coord_file = self.program.next_coords
+        
+        except Exception:
+            coord_file = None
+        
+        if coord_file:
+            main_si = si_from_file(coord_file, gen3D = False, charge = self.program.calculation.charge, multiplicity = self.program.calculation.multiplicity)
+            
+            self.data.atomnos = []
+            self.data.atomcoords = [[]]
+            
+            for atom in main_si.atoms:
+                self.data.atomnos.append(periodictable.elements.symbol(atom['atom']).number)
+                self.data.atomcoords[0].append(
+                    [
+                        atom['x'],
+                        atom['y'],
+                        atom['z']
+                    ]
+                )
+    
+    def post_parse(self):
+        """
+        Perform any required operations after line-by-line parsing.
+        """ 
+        super().post_parse()
+
+        try:
+            # Try to generate a checksum from metadata.
+            self.data._id = hashlib.sha1(json.dumps(self.data.metadata, sort_keys = True, default = str).encode('utf-8')).hexdigest()
+
+        except Exception:
+            # No luck, something in metadata must be unhashable.
+            digichem.log.get_logger().error("Unable to generate hash ID from calculation metadata, using random ID instead", exc_info = True)
+            # TODO: Think of a better way to do this.
+            self.data._id = hashlib.sha1(uuid4().hex.encode('utf-8')).hexdigest()
+        
+            

digichem/parse/crest.py

@@ -0,0 +1,89 @@
+import hashlib
+import json
+import datetime
+import periodictable
+from uuid import uuid4
+import types
+
+from digichem.parse.base import Parser_abc
+import digichem.log
+from digichem.input.digichem_input import si_from_file
+
+
+
+class Crest_parser(Parser_abc):
+    """
+    Top level class for parsing output from crest data.
+    """
+    
+    def __init__(self, mol_name, program, **kwargs):
+        self.program = program
+        self.mol_name = mol_name
+        super().__init__(**kwargs)
+
+    def _parse(self):
+        """
+        Extract results from our output files.
+        """
+        self.data = types.SimpleNamespace()
+
+        # Metadata we can get entirely from our passed in program object.
+        self.data.metadata = {
+            "name": self.mol_name,
+            "jobId": self.program.calculation.job_id,
+            "wall_time": [self.program.duration],
+            "cpu_time": [self.program.duration * self.program.calculation.performance['num_cpu']],
+            "date": datetime.datetime.now(datetime.timezone.utc).timestamp(),
+            "package": "CREST",
+            #"package_version": None,
+            "calculations": ["Optimisation"],
+            "success": not self.program.error,
+            "methods": [self.program.calculation.method['gfn']['level']],
+            "charge": self.program.calculation.charge,
+            "multiplicity": self.program.calculation.multiplicity,
+            "optimisation_converged": not self.program.error,
+            #"temperature": None,
+            #"pressure": None,
+            # TODO: CREST doesn't actually use orbitals...
+            "orbital_spin_type": "restricted",
+            "solvent_name": str(self.program.calculation.solution['solvent']) if self.program.calculation.solution['calc'] else None,
+            "solvent_model": self.program.calculation.solution['model'] if self.program.calculation.solution['calc'] else None,
+            "num_cpu": self.program.calculation.performance['num_cpu'],
+            #"memory_used": None,
+            "memory_available": self.program.calculation.performance['memory'],
+        }
+
+        # Crest calculations are normally used for conformer searching, so we should expect multiple structures as output.
+        # We'll use the lowest energy conformer as our 'main' structure.
+        main_si = si_from_file(self.program.working_directory / "crest_conformers.xyz", gen3D = False, charge = self.program.calculation.charge, multiplicity = self.program.calculation.multiplicity)
+        
+        self.data.atomnos = []
+        self.data.atomcoords = [[]]
+        
+        for atom in main_si.atoms:
+            self.data.atomnos.append(periodictable.elements.symbol(atom['atom']).number)
+            self.data.atomcoords[0].append(
+                [
+                    atom['x'],
+                    atom['y'],
+                    atom['z']
+                ]
+            )
+    
+    def post_parse(self):
+        """
+        Perform any required operations after line-by-line parsing.
+        """ 
+        super().post_parse()
+
+        try:
+            # Try to generate a checksum from metadata.
+            self.data._id = hashlib.sha1(json.dumps(self.data.metadata, sort_keys = True, default = str).encode('utf-8')).hexdigest()
+
+        except Exception:
+            # No luck, something in metadata must be unhashable.
+            digichem.log.get_logger().error("Unable to generate hash ID from calculation metadata, using random ID instead", exc_info = True)
+            # TODO: Think of a better way to do this.
+            self.data._id = hashlib.sha1(uuid4().hex.encode('utf-8')).hexdigest()
+        
+            

digichem/parse/pyscf.py

@@ -7,6 +7,7 @@ from cclib.bridge.cclib2pyscf import cclibfrommethods
 from digichem.parse.base import Parser_abc
 import digichem.log
 
+
 class Pyscf_parser(Parser_abc):
     """
     Top level class for parsing output from pyscf data.

digichem/result/atom.py

@@ -318,28 +318,30 @@ class Atom_list(Result_container, Unmergeable_container_mixin, Molecule_mixin):
             return self._smiles
         
         except AttributeError:
-            # Cache miss, go do some work.
+            pass
+        
+        # Cache miss, go do some work.
 
-            from rdkit.Chem import MolToSmiles
-            from rdkit.Chem.rdmolops import RemoveHs
-            
-            # TODO: Find some other way of generating SMILES.
+        from rdkit.Chem import MolToSmiles
+        from rdkit.Chem.rdmolops import RemoveHs
+        
+        # TODO: Find some other way of generating SMILES.
 
-            mol = self.to_rdkit_molecule()
-            try:
-                # TODO: rdkit is unreliable, this method can fail for lots of reasons...
-                mol = RemoveHs(mol)
-            except Exception:
-                pass
-                
-            self._smiles = MolToSmiles(mol)
-            return self._smiles
+        mol = self.to_rdkit_molecule()
+        try:
+            # TODO: rdkit is unreliable, this method can fail for lots of reasons...
+            mol = RemoveHs(mol)
+        except Exception:
+            pass
+            
+        self._smiles = MolToSmiles(mol)
+        return self._smiles
 
-            # # TODO: Handle cases where obabel isn't available
-            # conv = Openprattle_converter.get_cls("xyz")(input_file = self.to_xyz(), input_file_type = "xyz")
-            # # Cache the result in case we need it again.
-            # self._smiles = conv.convert("can").strip()
-            # return self._smiles
+        # # TODO: Handle cases where obabel isn't available
+        # conv = Openprattle_converter.get_cls("xyz")(input_file = self.to_xyz(), input_file_type = "xyz")
+        # # Cache the result in case we need it again.
+        # self._smiles = conv.convert("can").strip()
+        # return self._smiles
         
     @property
     def X_length(self):
@@ -567,9 +569,16 @@ class Atom_list(Result_container, Unmergeable_container_mixin, Molecule_mixin):
             rdDetermineBonds.DetermineBonds(mol, charge = self.charge)
         
         except Exception:
+            #formula_string may also not be implemented...
+            try:
+                formula_string = self.formula_string
+
+            except Exception:
+                formula_string = None
+            
             # This function is not implemented for some atoms (eg, Se).
             digichem.log.get_logger().warning(
-                "Unable to determine bond ordering for molecule; all bonds will be represented as single bonds only".format(self.formula_string)
+                "Unable to determine bond ordering for '{}'; all bonds will be represented as single bonds only".format(formula_string)
                 , exc_info = True
             )
         

digichem/result/metadata.py

@@ -354,6 +354,9 @@ class Metadata(Result_object):
         calculations = []
         if "Single Point" in self.calculations:
             calculations.append("single point energy")
+
+        if "Screening" in self.calculations:
+            calculations.append("conformer screening")
         
         if "Optimisation" in self.calculations:
             calculations.append("optimised structure")

{digichem_core-7.2.0.dist-info → digichem_core-7.3.0.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: digichem-core
-Version: 7.2.0
+Version: 7.3.0
 Summary: Open-source library for Digichem core components
 Project-URL: Homepage, https://github.com/Digichem-Project/digichem-core
 Project-URL: Documentation, https://doc.digi-chem.co.uk
 Project-URL: Issues, https://github.com/Digichem-Project/digichem-core/issues
 Author-email: "Oliver S. Lee" <osl@digi-chem.ac.uk>
-License: Copyright 2024 Digichem
+License: Copyright 2026 Digichem
         
         Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
         

{digichem_core-7.2.0.dist-info → digichem_core-7.3.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-digichem/__init__.py,sha256=ChTuRj6CsvNmgu2v8yY94WqAp_x78nVnyxhvEpo6XFU,1934
+digichem/__init__.py,sha256=KCCGEdjNGje8j9rag_4A1HgVuiokD86P25UF434ndJo,1934
 digichem/basis.py,sha256=khzIS9A_w8QH2vsXctWr16Bw5TA84_9_Fo-vuveP_5w,4875
-digichem/datas.py,sha256=t2PuQFvPb55WO_qVF3Xz67XNodQDimqYD26VkRPEWLA,433
+digichem/datas.py,sha256=I1yaPZ5nwKRFkwibqLd3kDw3s4mMkSzAjLqXCDwdqUw,473
 digichem/log.py,sha256=tjl8Er16HUsAibBZGZMu8KyT0w53YM3u0Neh_l2jD9Q,6166
 digichem/memory.py,sha256=_HJMwiElr0534lr3h17WwvXOi-DxCN-bAD1Ij8Lwg6U,5638
 digichem/translate.py,sha256=YKm7wko13A17zQJW8qOT52rzp9wDmR0GDzOepuzr75I,21326
@@ -44,40 +44,42 @@ digichem/image/base.py,sha256=6LGIYK2zB7lQxFhV5t2ZJPcpNMOqRv-JzrBJEeTF9Wg,5193
 digichem/image/excited_states.py,sha256=1YUa8KYXTvh_Vwl2DSaRwpIh15FtW18KpjLlnD8VTOk,14103
 digichem/image/graph.py,sha256=3wcembS3gcI5Ejq1lv4Sw1g_7s-fubDpiho_85kzkks,10880
 digichem/image/orbitals.py,sha256=UcPnOm3tQOdTegsVm_a7AizVe7OpBCz_4sve6u7jAvA,9705
-digichem/image/render.py,sha256=fQu9QcuIolzoeMoaQPQo27Z-JEXUCQCWiSVWQgv2iG4,30470
+digichem/image/render.py,sha256=vWBJS7W5yn2suwHrf2dqezyahpJb-Qvs8cLDQKv0g0k,30571
 digichem/image/spectroscopy.py,sha256=lB7O8QxeV0-B_jasr51XvBozfBjCOWwNgDW74HMxbqs,33998
 digichem/image/structure.py,sha256=gxgX5cXA3BaqBh5K7UPcVGWX-yG5kc6Robf5sWT1IYM,4900
 digichem/image/vmd.py,sha256=GGE35qypgBbpadHo1M929czuxM0U4NRICPkltKWEojE,39305
-digichem/input/__init__.py,sha256=DJMFLt-p2DZaTdvk2zIR6gdUepsa1n0e2_mk-BB45Sk,179
+digichem/input/__init__.py,sha256=unPAMm8CnD-UU0nIfc1_yX8uFNm63SksGO7POlIdiCY,197
 digichem/input/base.py,sha256=9nxut3IlvKSYCjRUzpi7SdlaO_4MU8KWAecV-z3T1jo,3082
-digichem/input/digichem_input.py,sha256=kAoLmphdIHLB4RoxHTXohTcL-L5iaYSl8peIR3vJPx8,19628
+digichem/input/digichem_input.py,sha256=zSM1w9ZbT_ncLzPwhBzAsjDE5Z4ZsXBBWfHz1EdFr1c,20751
 digichem/input/gaussian.py,sha256=W3JqRdsfebs_2G3grlYRv_dR1FsTBbf8YrxCNGwSd0U,6963
 digichem/misc/__init__.py,sha256=gRlflbkXYyKvqeQ2KTnNAdJ00S6Vhmk-tzSVCBSiWgk,162
 digichem/misc/argparse.py,sha256=AG33L7MCi-ftb4XnvndQb4hKcorzJxESAVB0HIZRlcw,1371
 digichem/misc/base.py,sha256=X75sM4X9aCQlzg8SrOnEr7GPFQkLBlaRXiE9tj8xj5o,2189
-digichem/misc/io.py,sha256=7Oqi7UQLwhCsVHdEN0n7Vubsbzk14fLSkAYXe4obPbQ,11007
+digichem/misc/io.py,sha256=Qzum8Lnc0EX0Ns90SllVDMM8zCJHZIextNqeUqsNrYQ,11172
 digichem/misc/layered_dict.py,sha256=Psf30UmHVHAE95RnFYiR2f7oaW05CsUhT4FtXhUtQcw,15561
 digichem/misc/text.py,sha256=FVcxf8ctt3D2yGFYgrZk3dpO48f_0aDhHiry_xGirD8,3673
 digichem/misc/time.py,sha256=Z7FWpkb8gqBHVMXdhFiBWn2VwmXuU9uaMxEKsfAH5Kw,2214
 digichem/parse/__init__.py,sha256=SIAj7do6mXRNuOEkN691Nh-je2YlZ3qL6fxnjsTE6QY,867
-digichem/parse/base.py,sha256=G7GULLX9YTSRote3o2MJk7nZ_wPrIKcG7Dyri5pyGCA,9175
-digichem/parse/cclib.py,sha256=g4a8r1IouVTz2N3Swmx8YVG5kZ5NnhBj6PoJpSP1eLY,10149
+digichem/parse/base.py,sha256=tuO9zW7JnX3L6dOHjgEkJ0FwYGmT4rDYSl1ppWqUIQI,13618
+digichem/parse/cclib.py,sha256=Ppw_3Y2GEk8p93Leqtv5GXH5ImgfEDN1OiuSA2N6ooI,6048
+digichem/parse/censo.py,sha256=MqQVosa71td6w-b7HVa01iw7ShmGP_iVzUXoN7hI4uE,6053
+digichem/parse/crest.py,sha256=AoPom9ihVyeDBB1ICC59L6JInNYYlmhKRHtDi5voYek,3632
 digichem/parse/dump.py,sha256=PnVwas1sFZTG9dgjAn7VLxQ8gSzTNllE-tx_PXh51DI,9332
 digichem/parse/gaussian.py,sha256=VaL0eotz2_b-OsWfzQioFU9JDDd3lYElrkXpLEy78fE,5344
 digichem/parse/orca.py,sha256=QahMQh-rZphDzyM8Kn6xEbEB9imCWpKUhUmlOxpDio0,4680
-digichem/parse/pyscf.py,sha256=DFR9xvM4ewHMM9-CikdaYq9I3Q78Xe7XA73x0cnLiIM,1465
+digichem/parse/pyscf.py,sha256=I_b4vYzjNlZaaZL_X3CVlwDI73hb5mSHeliIpVR3LN0,1466
 digichem/parse/turbomole.py,sha256=dulO8Y5txEABnK4Ybbp97KwOmnCrJMVSJSI9427SVIo,9133
 digichem/parse/util.py,sha256=QSxrRN3HFllVlsWqzTC4EKjj9w7t4kFbXuvhsMTpLIY,28930
 digichem/result/__init__.py,sha256=FUNL2pc2bP3XNVFRrlyrTppVWEsPRHcThLiVytpsH84,222
 digichem/result/angle.py,sha256=jehU0dRN4nALvUFzIdkh4GGQORq4lgXre8ZfFQMzB94,5043
-digichem/result/atom.py,sha256=TOlMiKYFe8vvBv9qCMBEJD1LYNzFtd7VePnUNCfCIbY,28287
+digichem/result/atom.py,sha256=y88x3tCnpR1nlOLqrkRMAPsyxaDbpf0LUQMa2dxSbY0,28439
 digichem/result/base.py,sha256=Lahahog9EHEQFP--DClyhiFIoJ0bRFJN37GH-Z2Nu2c,11615
 digichem/result/dipole_moment.py,sha256=1Z0qksmk7HYyov7318zWJQVXvteCo59DCCXd2rT2-hg,11082
 digichem/result/emission.py,sha256=XsyOgMtxV6wg9iBpPK-3WSbcIh6ohlZtGybMkuZaEbY,19785
 digichem/result/energy.py,sha256=iboiQF5Twa-TU9b_Utxg5B5U7RmL3LHtRp6XzmQHG0o,10899
 digichem/result/excited_state.py,sha256=FtQuW3R6yMCJMXmqxutwIleyYWqzDBgQ6O36sjWCSq0,34592
 digichem/result/ground_state.py,sha256=B8lOalD90uNq_pMHy0JhwYYY3rlWpcFlOHPLSO5CjhQ,3804
-digichem/result/metadata.py,sha256=Aak2tviK2HXfbr2m97AbNW1myfWVsSBwgT1ISLRKG88,38602
+digichem/result/metadata.py,sha256=JCz1NYiwhmVPQ3dQVTEQchfRo25QJ1pjO83HcaPs-Ng,38703
 digichem/result/multi.py,sha256=IzupKHMcXTf6AReeUCjY9Szy2b4TdOHVtC2Tlb9xg0o,4330
 digichem/result/nmr.py,sha256=vvhfVQSsi3fQ1VU_5POAUvwsJuN7XFidLkpmZy4UBzQ,50659
 digichem/result/orbital.py,sha256=8oMAtYSi8hYWWsjXJC2z5UAA47h0axM24ALqIo7yxFY,28292
@@ -109,8 +111,8 @@ digichem/test/test_translate.py,sha256=_3FkYottqHZGxMSTJkbcE8dQXhQlrNlVS0FjMopIw
 digichem/test/util.py,sha256=p1NfdSunB6WJM4BknyTDld7fGYWuvi2kHPu7pZcL9zE,8877
 digichem/test/mock/cubegen,sha256=h2HvmW8YbmYDqycnfCJYstZ2yO1uUxErbCWFKgzXaJ8,6781858
 digichem/test/mock/formchk,sha256=KZWhyJtaMXAGX1Xlx7Ikw9gbncOqLrpYkynz9IMYUlY,756867
-digichem_core-7.2.0.dist-info/METADATA,sha256=fB6uhPUZ02TY6dx1Uz-_mHDdsPiXPHpGUwMbN8N1ZcU,4094
-digichem_core-7.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-digichem_core-7.2.0.dist-info/licenses/COPYING.md,sha256=d-yG6IJrlqLkuiuoOFe331YKzMRS05pnmk4e98gu9pQ,900
-digichem_core-7.2.0.dist-info/licenses/LICENSE,sha256=ZLlePQN2WLgdvmIGLEjjHtgIoneUGR2MgE9yjMg1JiY,1457
-digichem_core-7.2.0.dist-info/RECORD,,
+digichem_core-7.3.0.dist-info/METADATA,sha256=3hH0iNtlNMF3mYeNjZbEUl9wcEXW-_UbCuX-1PbhJ_w,4094
+digichem_core-7.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+digichem_core-7.3.0.dist-info/licenses/COPYING.md,sha256=d-yG6IJrlqLkuiuoOFe331YKzMRS05pnmk4e98gu9pQ,900
+digichem_core-7.3.0.dist-info/licenses/LICENSE,sha256=b5-PNaQU9yZMNyXZKh5uzESv3Sb-bFhsXknE3B3UpMA,1457
+digichem_core-7.3.0.dist-info/RECORD,,

{digichem_core-7.2.0.dist-info → digichem_core-7.3.0.dist-info}/licenses/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2024 Digichem
+Copyright 2026 Digichem
 
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: