digichem-core 6.0.0rc1__py3-none-any.whl

digichem/file/fchk.py

@@ -0,0 +1,94 @@
+# General imports.
+import subprocess
+import os
+from pathlib import Path
+
+from digichem.exception.base import File_maker_exception
+
+# Digichem imports.
+from digichem.file import File_converter
+import digichem.file.types as file_types
+import digichem.log
+from digichem.memory import Memory
+from digichem.misc.io import expand_path
+
+class Chk_to_fchk(File_converter):
+    """
+    Class for creating Gaussian fchk files from Gaussian chk files.
+    """
+    
+    # Text description of our input file type, used for error messages etc.
+    #input_file_type = "chk"
+    input_file_type = file_types.gaussian_chk_file
+    # Text description of our output file type, used for error messages etc.
+    #output_file_type = "fchk"
+    output_file_type = file_types.gaussian_fchk_file
+    
+    def __init__(self, *args, chk_file = None, fchk_file = None, memory = None, formchk_executable = "formchk", **kwargs):
+        """
+        Constructor for Chk_to_fchk objects.
+        
+        See Image_maker for a full signature.
+        
+        :param output: The filename/path to the fchk file (this path doesn't need to point to a real file yet; we will use this path to write to).
+        :param chk_file: Optional chk_file to use to generate this fchk file.
+        :param fchk_file: An optional file path to an existing fchk file to use. If this is given (and points to an actual file), then a new fchk will not be made and this file will be used instead.
+        :param memory: The amount of memory for formchk to use.
+        :param formchk_executable: 'Path' to the executable to use for formchk.
+        """
+        super().__init__(*args, input_file = chk_file, existing_file = fchk_file, **kwargs)
+        memory = memory if memory is not None else "3 GB"
+        self.memory = Memory(memory)
+        self.formchk_executable = expand_path(formchk_executable)
+    
+    @classmethod
+    def from_options(self, output, *, chk_file = None, memory = None, options, **kwargs):
+        """
+        Constructor that takes a dictionary of config like options.
+        """        
+        return self(
+            output,
+            chk_file = chk_file,
+            memory = memory,
+            formchk_executable = options['external']['formchk'],
+            **kwargs
+        )
+        
+    def make_files(self):
+        """
+        Make the files referenced by this object.
+        """
+        input_file = Path(str(self.input_file))
+        
+        # The signature we'll use to call formchk.
+        signature = [
+            "{}".format(self.formchk_executable),
+            input_file.name,
+            str(self.output.absolute())
+        ]
+        
+        # Sadly (but not unexpectedly), the g09 version of formchk (and maybe other versions too) will crash if their are certain characters (at least '(' and ')') in the input directory name. The final part of the input name appears to be fine, as does everything in the output dir.
+        # This is easily fixed by making the output dir absolute and cd'ing into the input directory.
+                    
+        try:
+            formchk_proc =  subprocess.run(
+                signature,
+                # Capture both stdout and stderr.
+                stdout = subprocess.PIPE,
+                stderr = subprocess.STDOUT,
+                universal_newlines = True,
+                cwd = str(input_file.parent),
+                env = dict(os.environ, GAUSS_MEMDEF = str(self.memory))
+                )
+        except FileNotFoundError:
+            raise File_maker_exception(self, "Could not locate formchk executable '{}'".format(self.formchk_executable))
+        
+        # If something went wrong, dump output.
+        if formchk_proc.returncode != 0:
+            # An error occured.
+            raise File_maker_exception(self, "Formchk did not exit successfully:\n{}".format(formchk_proc.stdout))
+        else:
+            # Everything appeared to go ok.
+            # Dump formchk output if we're in debug.
+            digichem.log.get_logger().debug(formchk_proc.stdout)
+            

digichem/file/prattle.py

@@ -0,0 +1,277 @@
+# General imports.
+import subprocess
+from subprocess import CalledProcessError
+import re
+import os
+import copy
+from pathlib import Path
+import warnings
+import json
+
+# Digichem imports.
+from digichem.exception.base import Digichem_exception
+import digichem.log
+
+
+class Openprattle_converter():
+    """
+    Provides an interface to oprattle.
+
+    Openprattle provides a library interface, but because of the GPL we cannot use it.
+    Calling the oprattle command is fine, however.
+    """
+
+    def __init__(self, *, input_file = None, input_file_buffer = None, input_file_path = None, input_file_type = None, executable = "oprattle"):
+        """
+        Constructor for the OpenBabel converter.
+        
+        Input files can be specified in one of three ways:
+         - As an open file descriptor (input_file and input_file_type)
+         - As an in-memory buffer, most probably a string or bytes-like object (input_file_buffer and input_file_type)
+         - As a file path (input_file_path and optionally input_file_type)
+        
+        :param input_file: An open file descriptor in the format given by input_file_type that should be converted.
+        :param input_file_buffer: Alternatively, a buffer (unicode string or bytes) in the format given by input_file_type that should be converted.
+        :param input_file_path: Alternatively, a path to a file that should be converted.
+        :param input_file_type: A shortcode identifying the format of the input file. If not given but input_file_path is given, then this will be determined automatically.
+        :param executable: Path or command name to the oprattle executable.
+        """
+        self.input_file = input_file
+        self.input_file_buffer = input_file_buffer
+        self.input_file_path = input_file_path
+        self.input_file_type = input_file_type
+        self.executable = executable
+        
+    @property
+    def input_name(self):
+        """
+        A descriptive name of the file we are converting. Works even if converting from memory.
+        """
+        if self.input_file_path is not None:
+            return self.input_file_path
+        else:
+            return "(file loaded from memory)"
+        
+    @classmethod
+    def get_cls(self, input_file_type):
+        """
+        This function is deprecated, and does nothing.
+        """
+        warnings.warn("get_cls() is deprecated, use Openprattle_converter directly instead", DeprecationWarning)
+        return self
+        
+    @classmethod
+    def from_file(self, input_file_path, input_file_type = None, **kwargs):
+        """
+        This function is deprecated, and does nothing.
+        """
+        warnings.warn("from_file() is deprecated, use the Openprattle_converter constructor directly instead", DeprecationWarning)
+        return self.get_cls(None)(input_file_path = input_file_path, input_file_type = input_file_type, **kwargs)
+    
+    @classmethod
+    def type_from_file_name(self, input_file_name, allow_none = False):
+        """
+        Get the type of a file based on its file name.
+        
+        This method largely uses the file extension (.com, .tmol etc), with a few other simple rules.
+        
+        :param input_file_name: The name of the file to check.
+        :param allow_none: If the type of the file cannot be determined and allow_none is False (the default), an exception is raised. Otherwise, None is returned.
+        """
+        try:
+            input_file_name = Path(input_file_name)
+        
+        except TypeError:
+            if allow_none:
+                return None
+            
+            else:
+                # No file given.
+                raise ValueError("Could not automatically determine file format; no file name was given") from None
+        
+        # Get file extension (removing the dot character).
+        extension = input_file_name.suffix[1:]
+        
+        if extension != "":
+            # All done.
+            return extension.lower()
+        
+        elif input_file_name.name == "coord":
+            # This is a turbomole file.
+            return "tmol"
+        
+        else:
+            if allow_none:
+                return None
+            
+            else:
+                # Don't recognise the file format.
+                raise ValueError("Could not determine file format of file '{}'; the file does not have an extension and is not recognised".format(input_file_name))
+        
+    def convert(self, output_file_type = None, output_file = None, *, gen3D = None, charge = None, multiplicity = None):
+        """
+        Convert the input file wrapped by this class to the designated output_file_type.
+         
+        :param output_file_type: The file type to convert to.
+        :param output_file: Optional file name to write to. If not given, the converted file will be returned as a string (or binary string depending on format).
+        :param gen3D: If True and the loaded molecule does not have 3D coordinates, these will be generated (this will scramble atom coordinates).        
+        :param charge:  Optional charge of the output format.
+        :param multiplicity: Optional multiplicity of the output format.
+        :return: The converted file, or None if output_file is not None.
+        """
+        output_file = str(output_file) if output_file is not None else None
+        
+        # The signature we'll use to run oprattle.
+        sig = [
+            str(self.executable),
+            "--json"
+        ]
+        
+        # Add the input path if we're reading from file.
+        if self.input_file is None:
+            sig.append(str(self.input_file_path))
+            
+        # Now add the input and output switches.
+        if output_file_type:
+            sig.extend([
+                "-o", output_file_type
+            ])
+        if self.input_file_type:
+            sig.extend([
+                "-i", self.input_file_type
+            ])
+        
+        # Add gen3D command if we've been asked to.
+        if gen3D is True:
+            sig.extend(["--gen3D", "True"])
+        elif gen3D is False:
+            sig.extend(["--gen3D", "False"])
+            
+        # If a file to write to has been given, set it.
+        if output_file is not None:
+            sig.extend(['-O', output_file])
+        
+        # Give our input_file as stdin if we're not reading from file.
+        inputs = self.input_file        
+        
+        # GO.
+        try:
+            done_process = subprocess.run(
+                sig,
+                input = inputs,
+                stdout = subprocess.PIPE,
+                stderr = subprocess.PIPE,
+                # TODO: Using universal newlines is probably not safe here; some formats are binary (.cdx etc...)
+                universal_newlines = True,
+                check = True,
+            )
+
+        except CalledProcessError as e:
+            self.handle_logging(e.stderr)
+            raise
+
+        self.handle_logging(done_process.stderr)
+        
+        # Return our output.
+        return done_process.stdout if output_file is None else None
+    
+    def handle_logging(self, raw_output):
+        """
+        """
+        for raw_message in raw_output.split("\n"):
+            if raw_message == "":
+                # Nothing returned, nothing to do.
+                return
+            
+            # Each message should be in JSON, but check.
+            try:
+                message = json.loads(raw_message)
+                message_text = message['message']
+                if message['exception']:
+                    message_text += "\n" + message['exception']
+                digichem.log.get_logger().log(
+                    message['levelno'],
+                    message_text
+                )
+
+            except Exception:
+                digichem.log.get_logger().error("Unexpected output from oprattle: '{}'".format(raw_message), exc_info=False)
+    
+
+
+class Oprattle_formats():
+    """
+    Class for retrieving the supported file formats from oprattle.
+    """
+    
+    def __init__(self, executable = "oprattle"):
+        """
+        """
+        self.executable = executable
+    
+    def run(self, readwrite):
+        """
+        """
+        if readwrite not in ["read", "write"]:
+            raise ValueError("readwrite must be one of either 'read' or 'write'")
+        
+        # The signature we'll use to run oprattle.
+        sig = [
+            self.executable,
+            "--json",
+            "--readable" if readwrite == "read" else "--writable"
+        ]
+        
+        # GO.
+        done_process = subprocess.run(
+             sig,
+             stdout = subprocess.PIPE,
+             stderr = subprocess.PIPE,
+             universal_newlines = True,
+             check = True,
+         )
+        
+        formats = json.loads(done_process.stdout)
+        
+        return formats
+
+    
+    def read(self, refresh = False):
+        """
+        Retrieve supported input (read) formats.
+        """
+        if refresh:
+            try:
+                del self._read
+            
+            except AttributeError:
+                pass
+                
+        try:
+            return self._read
+        
+        except AttributeError:
+            # Cache miss.
+            self._read = self.run("read")
+            return self._read
+        
+    def write(self, refresh = False):
+        """
+        Retrieve supported input (read) formats.
+        """
+        if refresh:
+            try:
+                del self._write
+            
+            except AttributeError:
+                pass
+        
+        try:
+            return self._write
+        
+        except AttributeError:
+            # Cache miss.
+            self._write = self.run("write")
+            return self._write
+    
+    

digichem/file/types.py

@@ -0,0 +1,97 @@
+# Functions and classes for determining file types etc.
+from pathlib import Path
+from itertools import accumulate
+
+from digichem.exception.base import Unknown_file_type_exception
+
+class File_type():
+    """
+    Class for representing a known file type.
+    """
+    
+    def __init__(self, name, family = None, extensions = None, short_code = None):
+        """
+        Constructor for File_type objects.
+        
+        :param name: The name of the file (eg, "JPEG").
+        :param family: The name of the family/group that the file type belongs to (eg, "image").
+        :param extensions: An iterable of known file extensions (this is case-insensitive) (eg, [".jpg", ".jpeg"]).
+        """
+        self.name = name
+        self.family = family
+        self.extensions = [extension.lower() for extension in extensions] if extensions is not None else []
+        
+        if short_code is None and len(self.extensions) > 0:
+            # Take one of our extensions (without the dot).
+            self.short_code = self.extensions[0][1:]
+            
+        else:
+            self.short_code = short_code
+    
+    def check(self, file_path):
+        """
+        Determine whether a given file is of this file type.
+        
+        :param file_path: A string-like path to the file to check.
+        :return: True if the file is of this type, false otherwise.
+        """
+        # Get a Path object.
+        file_path = Path(file_path)
+        
+        # Check to see if the file extension matches one of our file extensions.
+        # We recurse through all the given file's extensions in case one of our extensions contains multiple parts (".tar.gz" for example).
+        for extension in accumulate(reversed(file_path.suffixes), lambda a, b: b+a):
+            if extension.lower() in self.extensions:
+                return True
+        
+        # No match found.
+        return False
+    
+    @property
+    def file_type(self):
+        """
+        Get a string uniquely identifying this file type.
+        """
+        if self.family is not None:
+            return "{}/{}".format(self.family, self.name)
+        else:
+            return self.name
+        
+    def __str__(self):
+        """
+        Stringify this file type.
+        """
+        return self.file_type
+    
+    
+# Known file types.
+log_file = File_type("log", "general", [".log"])
+gaussian_chk_file = File_type("checkpoint", "gaussian", [".chk"])
+gaussian_NTO_chk_file = File_type("NTO-checkpoint", "gaussian", [".chk"])
+gaussian_fchk_file = File_type("formatted-checkpoint", "gaussian", [".fchk"])
+gaussian_rwf_file = File_type("read-write", "gaussian", [".rwf"])
+gaussian_cube_file = File_type("cube", "gaussian", [".cub", ".cube"])
+
+orca_gbw_file = File_type("gbw", "orca", [".gbw"])
+orca_density_file = File_type("density", "orca", [".densities"])
+
+# A list of all our known types.
+known_types = [log_file, gaussian_chk_file, gaussian_fchk_file, gaussian_rwf_file, gaussian_cube_file, orca_gbw_file]
+
+# TODO: This seems to be unused?
+def get_file_type(file_path):
+    """
+    Get the type of a file from a list of known file types.
+    
+    :raises Unknown_file_type_exception: If the given file is of an unknown type.
+    :param file_path: String-like path to the file to check.
+    :return: A File_type object.
+    """
+    # Iterate through our list of known file types.
+    for file_type in known_types:
+        if file_type.check(file_path):
+            return file_type
+        
+    # Unknown file type.
+    raise Unknown_file_type_exception(file_path)
+

digichem/image/__init__.py

@@ -0,0 +1,6 @@
+import PIL.Image
+
+from .base import Image_maker
+
+# Remove PIL's built in max image size protection.
+PIL.Image.MAX_IMAGE_PIXELS = None

digichem/image/base.py

@@ -0,0 +1,113 @@
+from PIL import Image
+import numpy as np
+
+from digichem.file import File_maker
+from digichem.exception import File_maker_exception
+
+class Cropable_mixin():
+    """Mixin class for those that can crop their images."""
+    
+    @classmethod
+    def auto_crop_image(self, im):
+        """
+        Automatically remove excess white pixels around the outside of our image.
+        
+        :param im: A PIL Image object.
+        :returns: A new PIL Image object with white-space removed.
+        """
+        # (try to) load our image from file.
+        #im = Image.open(file_path, "r")
+        im.load()
+        
+        # This solution was inspired by https://stackoverflow.com/questions/14211340/automatically-cropping-an-image-with-python-pil
+        image_data = np.asarray(im)
+        if im.mode == "RGBA":
+            image_data_bw = image_data[:,:,3]
+
+            # Now we just check which rows and columns are not pure white.
+            non_empty_columns = np.where(image_data_bw.max(axis = 0) != 0)[0]
+            non_empty_rows = np.where(image_data_bw.max(axis = 1) != 0)[0]
+        
+        else:
+            # Axis 2 is the tuple/array of RGB values for each pixel. We want to know which ones are fully white (255,255,255), so we'll take the min of the 3 values and see if this is equal to 255. If it is, then all the pixels are 255        
+            image_data_bw = image_data.min(axis = 2)
+        
+            # Now we just check which rows and columns are not pure white.
+            non_empty_columns = np.where(image_data_bw.min(axis = 0) != 255)[0]
+            non_empty_rows = np.where(image_data_bw.min(axis = 1) != 255)[0]
+
+        if len(non_empty_rows) == 0 or len(non_empty_columns) == 0:
+            raise ValueError("The image is empty!")
+
+        # Get the bounding box of non-white stuff.
+        cropBox = (min(non_empty_rows), max(non_empty_rows), min(non_empty_columns), max(non_empty_columns))
+        
+        # Copy the image data we want.
+        image_data_new = image_data[cropBox[0]:cropBox[1]+1, cropBox[2]:cropBox[3]+1 , :]
+        
+        # And save over our old file.
+        new_image = Image.fromarray(image_data_new)
+        return new_image
+
+
+class Image_maker(File_maker, Cropable_mixin):
+    """
+    Top level class for image maker objects.
+    """
+    
+    # Text description of our output file type, used for error messages etc. This can be changed by inheriting classes.
+    output_file_type = "image"
+    
+    def __init__(self, *args, enable_rendering = True, **kwargs):
+        """
+        General constructor for Image_maker objects.
+        
+        These object are used to represent and make images. Note that a single Image_maker object can represent several image_files
+        
+        :param output: A path to an output file to write to. How exactly this operates depends on the inheriting class, it is often only used as a base file name. See the class you are using.
+        :param dont_modify: Flag that modifies how image creation works. If True, no new images will be written to file.
+        :param use_existing: Flag that modifies how image creation works. If True, existing files will be preferentially used if available (set to False to force overwriting existing files).
+        """
+        super().__init__(*args, existing_file = None, dont_modify = not enable_rendering, **kwargs)
+        
+    def get_image(self, name = 'file'):
+        """
+        Get the path to one of the images that this class represents, rendering the image to file first if necessary.
+        
+        The functioning of this method is controlled by the dont_modify & use_existing flags.
+        
+        You can also use the normal python attribute mechanism (either through getattr() or dot notation) to get these paths.
+        
+        :raises KeyError: If name is not the name of one of the images this class represents.
+        :param name: The name of an image to get. Depends on the images in self.file_path.
+        :return: A pathlib Path object pointing to the image represented by name, or None if no image could be created.
+        """
+        return self.safe_get_file(name)
+    
+    @property
+    def creation_message(self):
+        """
+        A short message that may (depending on log-level) be printed to the user before make_files() is called.
+        """
+        return "Rendering '{}' to file(s)".format(self.output if self.full_path_names else self.output.name)
+    
+        
+    def get_constrained_size(self, max_width, max_height):
+        """
+        Get the maximum possible dimensions of this image that retain the same aspect ratio that don't exceed a set of dimensions.
+        
+        :param max_width: The maximum width to resize to; set to math.inf for no max.
+        :param max_heigh: The maximum height to resize to; set to math.inf for no max.
+        """
+        # Weasyprint hack for broken max-width.
+                
+        # Now we open our diagram with pillow.
+        im = Image.open(self.get_image())
+        
+        width, height = im.size
+        
+        scale_factor = min(max_width/width, max_height/height)
+        
+        return (width *scale_factor, height * scale_factor)
+    
+