digichem-core 6.10.1__py3-none-any.whl → 7.0.0__py3-none-any.whl

digichem/parse/dump.py

@@ -25,19 +25,19 @@ class Dump_multi_parser_abc(File_parser_abc):
     ABC for classes that can read multiple result sets from dumped data.
     """
     
-    def __init__(self, input_file, *other_log_files, raw_data = None, **auxiliary_files):
+    def __init__(self, input_file, *other_log_files, raw_data = None, options , **auxiliary_files):
         """
         Top level constructor for calculation parsers.
         
         :param input_file: The path to read from.
         """
         # Neither other_log_files nor auxiliary_files are currently used...
-        super().__init__(input_file, raw_data = raw_data)
+        super().__init__(input_file, raw_data = raw_data, options = options)
         self.all_results = []
         
     @classmethod
-    def from_data(self, input_file, data):
-        return self(input_file, raw_data = data)
+    def from_data(self, input_file, data, options):
+        return self(input_file, raw_data = data, options = options)
             
     @property
     def results(self):
@@ -63,26 +63,24 @@ class Dump_multi_parser_abc(File_parser_abc):
     def get_sub_parser(self):
         raise NotImplementedError("Implement in subclass")
             
-    def process_all(self, options):
+    def process_all(self):
         """
         Get all the Result set objects produced by this parser.
         
-        :param options: A Digichem options nested dictionary containing options to control parsing.
         :return: A list of the populated result sets.
         """
         # Unlike most other parsers, our data can actually contain lots of results.
-        self.all_results = [self.get_sub_parser()(self.log_file_path, raw_data = data).process(options) for data in self.data]
+        self.all_results = [self.get_sub_parser()(self.log_file_path, raw_data = data, options = self.options).process() for data in self.data]
         
         return self.all_results
     
-    def process(self, options):
+    def process(self):
         """
         Get a Result set object from this parser.
         
-        :param options: A Digichem options nested dictionary containing options to control parsing.
         :return: The populated result set.
         """
-        self.process_all(options)
+        self.process_all()
         return self.results
     
     
@@ -127,65 +125,63 @@ class Dump_parser_abc(File_parser_abc):
     ABC for parsers that read dumped data.
     """
     
-    def __init__(self, input_file, *other_log_files, raw_data = None, **auxiliary_files):
+    def __init__(self, input_file, *other_log_files, raw_data = None, options, **auxiliary_files):
         """
         Top level constructor for calculation parsers.
         
         :param input_file: The path to the input file to read.
         """
         # Neither other_log_files nor auxiliary_files are currently used...
-        super().__init__(input_file, raw_data = raw_data)
+        super().__init__(input_file, raw_data = raw_data, options = options)
         
     @classmethod
-    def from_data(self, input_file, data):
-        return self(input_file, raw_data = data)
+    def from_data(self, input_file, data, options):
+        return self(input_file, raw_data = data, options = options)
     
-    def process_all(self, options):
+    def process_all(self):
         """
         Get all the Result set objects produced by this parser.
         
-        :param options: A Digichem options nested dictionary containing options to control parsing.
         :return: A list of the populated result sets.
         """
-        self.process(options)
+        self.process()
         return [self.results]
             
-    def process(self, options):
+    def process(self):
         """
         Get a Result set object from this parser.
         
-        :param options: A Digichem options nested dictionary containing options to control parsing.
         :return: The populated result set.
         """
         
         # Get our result set.
         self.results = Result_set(
             _id = self.data.get("_id"),
-            metadata = Metadata.from_dump(self.data['metadata'], self.results, options)
+            metadata = Metadata.from_dump(self.data['metadata'], self.results, self.options)
         )
         
         # First get our list of MOs (because we need them for excited states too.)
-        self.results.orbitals = Molecular_orbital_list.from_dump(self.data['orbitals'], self.results, options)
-        self.results.beta_orbitals = Molecular_orbital_list.from_dump(self.data['beta_orbitals'], self.results, options)
+        self.results.orbitals = Molecular_orbital_list.from_dump(self.data['orbitals'], self.results, self.options)
+        self.results.beta_orbitals = Molecular_orbital_list.from_dump(self.data['beta_orbitals'], self.results, self.options)
         
-        alignment_class = Alignment.from_class_handle(options['alignment']) if options['alignment'] is not None else Minimal
+        alignment_class = Alignment.from_class_handle(self.options['alignment']) if self.options['alignment'] is not None else Minimal
         
         # Our alignment orientation data.
         # The constructor for each alignment class automatically performs realignment.
-        self.results.atoms = alignment_class.from_dump(self.data['atoms'], self.results, options)
-        self.results.raw_atoms = Atom_list.from_dump(self.data['raw_atoms'], self.results, options)
+        self.results.atoms = alignment_class.from_dump(self.data['atoms'], self.results, self.options)
+        self.results.raw_atoms = Atom_list.from_dump(self.data['raw_atoms'], self.results, self.options)
         
         # TEDM and TMDM.
-        self.results.transition_dipole_moments = Transition_dipole_moment.list_from_dump(self.data['excited_states']['values'], self.results, options)
+        self.results.transition_dipole_moments = Transition_dipole_moment.list_from_dump(self.data['excited_states']['values'], self.results, self.options)
         
         # Excited states.
-        self.results.excited_states = Excited_state_list.from_dump(self.data['excited_states'], self.results, options)
+        self.results.excited_states = Excited_state_list.from_dump(self.data['excited_states'], self.results, self.options)
         
         # Energies.
-        self.results.energies = Energies.from_dump(self.data['energies'], self.results, options)
+        self.results.energies = Energies.from_dump(self.data['energies'], self.results, self.options)
         
         # Our ground state.
-        self.results.ground_state = Ground_state.from_dump(self.data['ground_state'], self.results, options)
+        self.results.ground_state = Ground_state.from_dump(self.data['ground_state'], self.results, self.options)
         
         # And a similar list but also including the ground.
         self.results.energy_states = Excited_state_list()
@@ -193,24 +189,24 @@ class Dump_parser_abc(File_parser_abc):
         self.results.energy_states.extend(self.results.excited_states)
         
         # SOC.
-        self.results.soc = SOC_list.from_dump(self.data['soc'], self.results, options)
+        self.results.soc = SOC_list.from_dump(self.data['soc'], self.results, self.options)
         
         # PDM
-        self.results.pdm = Dipole_moment.from_dump(self.data['pdm'], self.results, options)
+        self.results.pdm = Dipole_moment.from_dump(self.data['pdm'], self.results, self.options)
         
         # Frequencies.
-        self.results.vibrations = Vibrations_list.from_dump(self.data['vibrations'], self.results, options)
+        self.results.vibrations = Vibrations_list.from_dump(self.data['vibrations'], self.results, self.options)
         
         # NMR.
         if "nmr" in self.data:
-            self.results.nmr = NMR_list.from_dump(self.data['nmr'], self.results, options)
+            self.results.nmr = NMR_list.from_dump(self.data['nmr'], self.results, self.options)
         
         else:
-            self.results.nmr = NMR_list(atoms = self.results.atoms, options = options)
+            self.results.nmr = NMR_list(atoms = self.results.atoms, options = self.options)
             
         # Finally, try and set emission.
         try:
-            self.results.emission = self.results.emission.from_dump(self.data['emission'], self.results, options)
+            self.results.emission = self.results.emission.from_dump(self.data['emission'], self.results, self.options)
         
         except Exception:
             digichem.log.get_logger().warning("Failed to parse emission data", exc_info = True)

digichem/parse/gaussian.py

@@ -29,9 +29,9 @@ class Gaussian_parser(Cclib_parser):
     CPU_TIME_HEADER = "Job cpu time:"
     CPU_HEADER = "Will use up to"
 
-    def __init__(self, *log_files, rwfdump = "rwfdump", **auxiliary_files):
+    def __init__(self, *log_files, rwfdump = "rwfdump", options, **auxiliary_files):
         self.rwfdump = rwfdump
-        super().__init__(*log_files, **auxiliary_files)
+        super().__init__(*log_files, options = options, **auxiliary_files)
     
     def parse_metadata(self):
         """

digichem/parse/pyscf.py

@@ -1,9 +1,11 @@
 import hashlib
 import json
+from uuid import uuid4
 
 from cclib.bridge.cclib2pyscf import cclibfrommethods
 
 from digichem.parse.base import Parser_abc
+import digichem.log
 
 class Pyscf_parser(Parser_abc):
     """
@@ -17,9 +19,17 @@ class Pyscf_parser(Parser_abc):
 
     def _parse(self):
         self.data = cclibfrommethods(**self.methods)
-        # TODO: We need some way of generating a checksum
-        self.data._id = hashlib.sha1(json.dumps(dir(self.data), sort_keys = True).encode('utf-8')).hexdigest()
+        
+        try:
+            # Try to generate a checksum from metadata.
+            self.data._id = hashlib.sha1(json.dumps(self.data.metadata, sort_keys = True).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()
+        
         self.data.metadata['name'] = self.mol_name
         self.data._aux = {'methods': self.methods}
-            
             

digichem/parse/turbomole.py

@@ -98,14 +98,13 @@ class Turbomole_parser(Cclib_parser):
         if len(self.data.metadata['cpu_time']) == 0:
             del(self.data.metadata['cpu_time'])
 
-    def process(self, options):
+    def process(self):
         """
         Get a Result set object from this parser.
         
-        :param options: A Digichem options nested dictionary containing options to control parsing.
         :return: The populated result set.
         """
-        super().process(options)
+        super().process()
         
         # After processing is complete, have a look for excited state density files.
         # These have the general file name:

digichem/parse/util.py

@@ -60,7 +60,7 @@ def find_log_files_from_hint(hint):
         # Remove any 'digichem.log' files as we know these are not calc log files.
         # We don't actually write 'digichem.log' files anymore either (we use digichem.out instead),
         # but older versions did...
-        log_files = [log_file for log_file in log_files if log_file.name not in ["digichem.log", "digichem.out", "silico.log", "silico.out"]]
+        log_files = [log_file for log_file in log_files if log_file.name not in ["digichem.log", "digichem.out", "silico.log", "silico.out", ".digichem.yaml"]]
     else:
         parent = hint.parent
         log_files = [hint]
@@ -227,10 +227,10 @@ def parse_calculation(*log_files, options, parse_all = False, format_hint = "aut
         open_log_files, open_aux_files = archive.open()
         
         if parse_all:
-            results = from_log_files(*open_log_files, format_hint = format_hint, parser_options = parser_options, **open_aux_files).process_all(options)
+            results = from_log_files(*open_log_files, format_hint = format_hint, parser_options = parser_options, options = options, **open_aux_files).process_all()
         
         else:       
-            results = from_log_files(*open_log_files, format_hint = format_hint, parser_options = parser_options, **open_aux_files).process(options)
+            results = from_log_files(*open_log_files, format_hint = format_hint, parser_options = parser_options, options = options, **open_aux_files).process()
         
     finally:
         if not keep_archive:
@@ -379,7 +379,6 @@ def parse_and_merge_multiple_calculations(*multiple_results, options, parser_opt
     :param multiple_results: A list of two dimensions, where the first dimension is a list of separate results to process, and the second dimension is a list of results that should be merged together.
     :param options: A Digichem options nested dictionary containing options to control parsing.
     :param format_hint: A hint as to the format of the given log files. Either 'auto' (to guess), 'log' (calc log file), 'sir' (digichem result file) or 'sid' (digichem database file).
-    :param pool: An optional subprocessing.pool object to use for parallel parsing.
     :param init_func: An optional function to call to init each newly created process.
     :param processes: The max number of processes to create the new pool object with.
     :param auxiliary_files: An optional list of lists of dicts of auxiliary files. Each item in auxiliary_files should match the corresponding log file in multiple_results.
@@ -388,6 +387,7 @@ def parse_and_merge_multiple_calculations(*multiple_results, options, parser_opt
     if auxiliary_files is None:
         auxiliary_files = [None] * len(multiple_results)
     
+    pool = None
     # Do some parsing.
     # TODO: This parallelization isn't ideal, currently we process each group of to-be merged calcs separately, meaning processes can be wasted.
     try:
@@ -402,7 +402,8 @@ def parse_and_merge_multiple_calculations(*multiple_results, options, parser_opt
         return result_lists
     
     finally:
-        pool.__exit__(None, None, None)
+        if pool:
+            pool.__exit__(None, None, None)
     
 
 class open_for_parsing():

digichem/result/alignment/base.py

@@ -240,11 +240,11 @@ class Alignment(Atom_list, Dynamic_parent):
         for atom in self:
             print("{}, {}, {}, {}".format(atom.element, atom.coords[0], atom.coords[1], atom.coords[2]))
             
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
-        dump_dict = super().dump(digichem_options)
+        dump_dict = super()._dump_(digichem_options, all)
         dump_dict['alignment_method'] = self.human_method_type
         return dump_dict
     

digichem/result/atom.py

@@ -453,7 +453,7 @@ class Atom_list(Result_container, Unmergeable_container_mixin, Molecule_mixin):
         """
         return self(Atom.list_from_coords(coords), charge = coords.charge)
     
-    def dump(self, Digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
@@ -490,7 +490,7 @@ class Atom_list(Result_container, Unmergeable_container_mixin, Molecule_mixin):
             },
             "linearity_ratio": float(self.get_linear_ratio()),
             "planarity_ratio": float(self.get_planar_ratio()),
-            "values": super().dump(Digichem_options),
+            "values": super()._dump_(digichem_options, all),
         }
         return dump_dict
     
@@ -522,7 +522,7 @@ class Atom_list(Result_container, Unmergeable_container_mixin, Molecule_mixin):
         """
         Convert this list of atoms to mol format (useful for reading with rdkit).
         """
-        return Openprattle_converter.get_cls("xyz")(input_file = self.to_xyz(), input_file_path = "internal atoms object", input_file_type = "xyz").convert("mol", charge = self.charge)
+        return Openprattle_converter(input_file_buffer = self.to_xyz(), input_file_path = "internal atoms object", input_file_type = "xyz").convert("mol", charge = self.charge)
     
     def to_rdkit_molecule(self):
         """
@@ -673,7 +673,7 @@ class Atom(Atom_ABC):
         """
         return math.sqrt( (self.coords[0] - foreign_atom.coords[0])**2 + (self.coords[1] - foreign_atom.coords[1])**2 + (self.coords[2] - foreign_atom.coords[2])**2)
     
-    def dump(self, Digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """

digichem/result/base.py

@@ -93,17 +93,55 @@ class Result_object():
             
         return multiple_objects[0]
     
+    def calculate(self, item, digichem_options):
+        """
+        Retrieve/calculate an on-demand value, caching the value if it has not already been retrieved.
+
+        This function is a wrapper around _get_dump_(), caching the calculation result to avoid
+        expensive recalculation.
+
+        :param item: The key corresponding to an item in this object's _get_dump_() dict.
+        :param digichem_options: Digichem options that will be passed to _get_dump_() (unused on a cache hit).
+        """
+        if not hasattr(self, "_dump_cache"):
+            self._dump_cache = {}
+
+        if item in self._dump_cache:
+            # Cache hit.
+            return self._dump_cache[item]
+
+        else:
+            # Cache miss.
+            # Generate (and cache) the data.
+            self._dump_cache[item] = self.generate_for_dump()[item](digichem_options)
+
+            # And return of course.
+            return self._dump_cache[item]
+    
     def generate_for_dump(self):
         """
         Method used to get a dictionary used to generate on-demand values for dumping.
         
         This functionality is useful for hiding expense properties from the normal dump process, while still exposing them when specifically requested.
         
-        Each key in the returned dicrt is the name of a dumpable item, each value is a function to call with digichem_options as its only param.
+        Each key in the returned dict is the name of a dumpable item, each value is a function to call with digichem_options as its only param.
         """
-        return {}
+        warnings.warn("generate_for_dump() is deprecated, use calculate() or _get_dump_() instead", DeprecationWarning)
+        return self._get_dump_()
     
-    def dump(self, digichem_options):
+    def dump(self, digichem_options, all = False):
+        # First, get simple key:value pairs.
+        base_dict = self._dump_(digichem_options, all)
+
+        # Then extend with generator ones if we have any.
+        if all:
+            generators = self._get_dump_()
+            for key in generators:
+                base_dict[key] = generators[key](digichem_options)
+        
+        return base_dict
+    
+    def _dump_(self, digichem_options, all):
         """
         Abstract function that is called to dump the value of the result object to a primitive type, suitable for serializing with yaml.
         
@@ -112,6 +150,16 @@ class Result_object():
          - 'units': The units of the result (for example, k m^-s).
         """
         raise NotImplementedError("Implement in subclass")
+    
+    def _get_dump_(self):
+        """
+        Method used to get a dictionary used to generate on-demand values for dumping.
+        
+        This functionality is useful for hiding expense properties from the normal dump process, while still exposing them when specifically requested.
+        
+        Each key in the returned dict is the name of a dumpable item, each value is a function to call with digichem_options as its only param.
+        """
+        return {}
 
 
 class Floatable_mixin():
@@ -253,6 +301,6 @@ class Result_container(list, Result_object):
         else:
             return self.merge_default(*multiple_lists, **kwargs)
         
-    def dump(self, digichem_options):
-        return [item.dump(digichem_options) for item in self]
+    def _dump_(self, digichem_options, all):
+        return [item.dump(digichem_options, all) for item in self]
     

digichem/result/dipole_moment.py

@@ -182,7 +182,7 @@ class Dipole_moment_ABC(Result_object):
         except (FloatingPointError, ZeroDivisionError):
             return 0
         
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """

digichem/result/emission.py

@@ -27,11 +27,11 @@ class Emissions(Result_object):
         self.adiabatic = adiabatic if adiabatic is not None else {}
         self.vertical = vertical if vertical is not None else {}
         
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         # Several dumpers (JSON, DB backends based on JSON etc) don't support non-string keys...
         return {
-            "adiabatic": {str(key):value.dump(digichem_options) for key,value in self.adiabatic.items()},
-            "vertical": {str(key):value.dump(digichem_options) for key,value in self.vertical.items()}
+            "adiabatic": {str(key):value.dump(digichem_options, all) for key,value in self.adiabatic.items()},
+            "vertical": {str(key):value.dump(digichem_options, all) for key,value in self.vertical.items()}
         }
         
     @classmethod
@@ -343,12 +343,12 @@ class Relaxed_excited_state(Excited_state):
             else:
                 raise
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
         
-        dump_dict = super().dump(digichem_options)
+        dump_dict = super()._dump_(digichem_options, all)
         dump_dict['emission_type'] = self.emission_type
         dump_dict['ground_multiplicity'] = self.ground_multiplicity
         dump_dict['excited_energy'] = {

digichem/result/energy.py

@@ -65,7 +65,7 @@ class Energies(Result_object):
             scf = SCF_energy_list.from_parser(parser)
         )
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
@@ -74,11 +74,11 @@ class Energies(Result_object):
                 "value": float(self.final),
                 "units": "eV"
             },
-            "scf": self.scf.dump(digichem_options),
-            "mp": self.mp.dump(digichem_options),
-            "cc": self.cc.dump(digichem_options)
+            "scf": self.scf.dump(digichem_options, all),
+            "mp": self.mp.dump(digichem_options, all),
+            "cc": self.cc.dump(digichem_options, all)
         }
-        dump.update({"mp{}".format(index+2): energy.dump(digichem_options) for index, energy in enumerate(self.mp_energies)})
+        dump.update({"mp{}".format(index+2): energy.dump(digichem_options, all) for index, energy in enumerate(self.mp_energies)})
         return dump
         
     @classmethod
@@ -210,7 +210,7 @@ class Energy_list(Result_container, Unmergeable_container_mixin):
         except AttributeError:
             return self()
         
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
@@ -270,11 +270,11 @@ class MP_energy_list(Energy_list):
         super().__init__(items)
         self.order = order
         
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
-        dump = super().dump(digichem_options)
+        dump = super()._dump_(digichem_options, all)
         dump['order'] = self.order
         return dump
     

digichem/result/excited_state.py

@@ -230,7 +230,7 @@ class Excited_state_list(Result_container):
         merged.assign_levels()
         return merged
     
-    def generate_for_dump(self):
+    def _get_dump_(self):
         """
         Method used to get a dictionary used to generate on-demand values for dumping.
         
@@ -257,14 +257,21 @@ class Excited_state_list(Result_container):
         # TODO: It's weird that these spectra are only available in dumped format, there should be some property/function on the class that also returns them...
         spectrum_nm = Absorption_emission_graph.from_excited_states(
             self,
-            digichem_options['absorption_spectrum']['fwhm'],
-            digichem_options['absorption_spectrum']['gaussian_resolution'],
-            digichem_options['absorption_spectrum']['gaussian_cutoff'],
+            fwhm = digichem_options['absorption_spectrum']['fwhm'],
+            resolution = digichem_options['absorption_spectrum']['gaussian_resolution'],
+            cutoff = digichem_options['absorption_spectrum']['gaussian_cutoff'],
+            filter = digichem_options['absorption_spectrum']['y_filter'],
             use_jacobian = digichem_options['absorption_spectrum']['use_jacobian']
         )
         
         
-        spectrum_ev = Spectroscopy_graph([(excited_state.energy, excited_state.oscillator_strength) for excited_state in self], digichem_options['absorption_spectrum']['fwhm'], digichem_options['absorption_spectrum']['gaussian_resolution'], digichem_options['absorption_spectrum']['gaussian_cutoff'])
+        spectrum_ev = Spectroscopy_graph(
+            [(excited_state.energy, excited_state.oscillator_strength) for excited_state in self],
+            fwhm = digichem_options['absorption_spectrum']['fwhm'],
+            resolution = digichem_options['absorption_spectrum']['gaussian_resolution'],
+            cutoff = digichem_options['absorption_spectrum']['gaussian_cutoff'],
+            filter = digichem_options['absorption_spectrum']['y_filter']
+        )
         
         try:
             spectrum_nm_data = spectrum_nm.plot_cumulative_gaussian()
@@ -298,9 +305,9 @@ class Excited_state_list(Result_container):
             }    
         }
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         dump_dict = {
-            "values": super().dump(digichem_options),
+            "values": super()._dump_(digichem_options, all),
         }
         
         # Add extra properties.
@@ -358,7 +365,7 @@ class Excited_state_transition(Result_object):
         """
         return self.coefficient **2
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
@@ -558,7 +565,7 @@ class Energy_state(Result_object, Floatable_mixin):
         """
         return "{}({})".format(self.multiplicity_symbol, self.multiplicity_level)
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
@@ -708,11 +715,11 @@ class Excited_state(Energy_state):
         # Now convert to 0 -> 255 and return.
         return [int(clr * 255) for clr in rgb]    
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
-        dump_dict = super().dump(digichem_options)
+        dump_dict = super()._dump_(digichem_options, all)
         dump_dict.update({
             "wavelength": {
                 "value": float(self.wavelength),
@@ -725,8 +732,8 @@ class Excited_state(Energy_state):
             },
             "symmetry": self.symmetry,
             "oscillator_strength": float(self.oscillator_strength) if self.oscillator_strength is not None else None,
-            "tdm": self.transition_dipole_moment.dump(digichem_options) if self.transition_dipole_moment is not None else None,
-            "transitions": [tran.dump(digichem_options) for tran in self.transitions],
+            "tdm": self.transition_dipole_moment.dump(digichem_options, all) if self.transition_dipole_moment is not None else None,
+            "transitions": [tran.dump(digichem_options, all) for tran in self.transitions],
         })
         return dump_dict
         

digichem/result/ground_state.py

@@ -35,11 +35,11 @@ class Ground_state(Energy_state):
         """
         return self.charge == other.charge and self.multiplicity == other.multiplicity and self.energy == other.energy
         
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
-        parent_dict = super().dump(digichem_options)
+        parent_dict = super()._dump_(digichem_options, all)
         return {
             "index": parent_dict['index'],
             "symbol": parent_dict['symbol'],