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

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'],

digichem/result/metadata.py

@@ -46,10 +46,10 @@ class Solvent(Result_object):
     @classmethod
     def from_parser(self, parser):
         """
-        Construct a Metadata object from an output file parser.
+        Construct a Solvent object from an output file parser.
         
         :param parser: Output data parser.
-        :return: A populated Metadata object.
+        :return: A populated Solvent object.
         """
         return self(
             name = parser.data.metadata.get('solvent_name', None),
@@ -78,7 +78,7 @@ class Solvent(Result_object):
         else:
             return "Unknown"
         
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         return {
             "model": self.model,
             "name": self.name,
@@ -142,6 +142,7 @@ class Metadata(Result_object):
     
     def __init__(
             self,
+            jobId = None,
             name = None,
             user = None,
             log_files = None,
@@ -177,6 +178,7 @@ class Metadata(Result_object):
         """
         Constructor for result Metadata objects.
         
+        :param jobId: If this result was generated from a digichem calculation, the relevant jobID.
         :param name: Optional name of this calculation result.
         :param user: The username of the user who parsed this result.
         :param log_files: An optional list of text-based calculation log files from which this result was parsed.
@@ -203,6 +205,7 @@ class Metadata(Result_object):
         :param memory_available: The maximum amount of memory available to this calculation (the amount requested by the user).
         :param memory_used: The maximum amount of memory used by the calculation (the amount requested by the user).
         """
+        self.jobId = jobId
         self.num_calculations = 1
         self.name = name
         self.user = user
@@ -453,6 +456,7 @@ class Metadata(Result_object):
             
             # TODO: This doesn't seem to make sense; the parser already contains a metadata object...
             return self(
+                jobId = parser.data.metadata.get('jobId', None),
                 name = parser.data.metadata.get('name', None),
                 user = parser.data.metadata.get('user', None),
                 log_files = parser.data.metadata.get('log_files', None),
@@ -485,7 +489,7 @@ class Metadata(Result_object):
             # There is no metadata available, give up.
             raise Result_unavailable_error("Metadata", "no metadata is available")
         
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
@@ -497,6 +501,7 @@ class Metadata(Result_object):
         }
         
         attrs = [
+            "jobId",
             "history",
             "charge",
             "multiplicity",
@@ -538,7 +543,7 @@ class Metadata(Result_object):
             "value": self.pressure,
             "units": "atm"
         }
-        attr_dict["solvent"] = self.solvent.dump(digichem_options)
+        attr_dict["solvent"] = self.solvent.dump(digichem_options, all)
         
         attr_dict['num_cpu'] = self.num_cpu
         for attr_name in ("memory_used", "memory_available"):
@@ -554,7 +559,7 @@ class Metadata(Result_object):
                     "units": None
                 }
         
-        attr_dict['performance'] = self.performance.dump(digichem_options) if self.performance else None
+        attr_dict['performance'] = self.performance.dump(digichem_options, all) if self.performance else None
 
         return attr_dict
     
@@ -731,20 +736,6 @@ class Performance(Result_object):
             scratch_available = parser.data.metadata['performance']['scratch_available'].tolist()
         )
     
-
-        return self(
-            duration = parser.data.metadata['performance'][:, 0].tolist(),
-            memory_used = parser.data.metadata['performance'][:, 1].tolist(),
-            memory_allocated = Memory(parser.data.metadata['memory_available']) if "memory_available" in parser.data.metadata else None,
-            memory_used_percent = parser.data.metadata['performance'][:, 2].tolist(),
-            memory_available = parser.data.metadata['performance'][:, 3].tolist(),
-            memory_available_percent = parser.data.metadata['performance'][:, 4].tolist(),
-            cpu_used = parser.data.metadata['performance'][:, 5].tolist(),
-            cpu_allocated = parser.data.metadata.get('num_cpu', None),
-            output_space = parser.data.metadata['performance'][:, 6].tolist(),
-            scratch_space = parser.data.metadata['performance'][:, 7].tolist()
-        )
-    
     @property
     def max_mem(self):
         """
@@ -846,7 +837,7 @@ class Performance(Result_object):
         )
 
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """