digichem-core 6.0.0rc1__py3-none-any.whl

digichem/input/gaussian.py

@@ -0,0 +1,140 @@
+from digichem.exception import Digichem_exception
+
+
+class Gaussian_input_parser():
+    """
+    Class for parsing Gaussian input files.
+    """
+    
+    # Each 'section' in Gaussian is separated by a double newline; this seems to be the only consistent delimiter.
+    SECTION_SEPARATOR = "\n\n"
+    
+    def __init__(self, file_str = None):
+        """
+        Constructor for Gaussian input files.
+        
+        :param file_str: String containing a Gaussian input file.
+        """
+        # Link 0 commands that appear at the top of the input file, we currently do no parsing on these (because we ignore them anyway)
+        # Link 0 commands are stored as they appear (as a string, possibly containing newlines).
+        self.link_0 = None
+        
+        # The route section, describes the calculation to be performed.
+        ## Most of the route is ignored as we set it ourselves as part of the submission process, but some options (geom=connectivity, genECP etc) control the format of the rest of the file, so we do parse these.
+        ## This is a dictionary of options; where 'key: value' translates to 'key=value' in the gaussian file. If value is None, then the translation is to 'key'.
+        # The route section is currently not parsed (it is just a string).        
+        self.route = None
+        
+        # The title of the input file.
+        self.title = None
+        
+        # The multiplicity and charge of the molecule, appears at the top of the geometry section as 'charge, mult' or 'charge mult'.
+        self.multiplicity = None
+        self.charge = None
+        
+        # The geometry (atoms and charge etc) section as a string (almost certainly containing newlines).
+        self.geometry = None
+        
+        # These are additional sections that can optionally appear in some input files (connectivity, basis set etc).
+        self.additional_sections = []
+        # If we've been given a file, load it now.
+        if file_str is not None:
+            self.load(file_str)
+        
+    @property
+    def title(self):
+        """
+        Get the title section of this input file.
+        
+        None and empty string values are translated to a single whitespace character (because otherwise they will be interpreted wrong).
+        """
+        if self._title is not None and len(self._title.trim()) != 0:
+            return self._title
+        
+        else:
+            return "(title)"
+    
+    @title.setter
+    def title(self, value):
+        """
+        Set the title section of this input file.
+        """
+        self._title = value
+    
+    def load(self, file_str):
+        """
+        Load a Gaussian input file.
+        
+        :param file_str: String containing a Gaussian input file.
+        
+        """
+        # First, split on our delimeter.
+        sections = file_str.split("\n\n")
+        
+        link_0_lines = []
+        route_lines = []
+        # Split the first section into link 0 and route (link 0 starts with %, the first line not to start without % is route).
+        if len(sections) > 0:
+            in_route = False
+            for line in sections[0].split("\n"):
+                # Check first char.
+                if not in_route and line[:1] != "%":
+                    in_route = True
+                    
+                # Add to one of our two lists.
+                if not in_route:
+                    link_0_lines.append(line)
+                else:
+                    route_lines.append(line)
+        
+        # Now set.
+        self.link_0 = "\n".join(link_0_lines) if len(link_0_lines) > 0 else None
+        self.route = "\n".join(route_lines) if len(route_lines) > 0 else None
+        
+        # Set title.
+        self.title = sections[1] if len(sections) > 1 else None
+        
+        # Geometry (the first line contains charge and mult).
+        try:
+            geometry_section = sections[2].split("\n", 1)
+        except IndexError:
+            # No geometry available.
+            raise Digichem_exception("Failed to read Gaussian geometry data from input file; is the file formatted correctly?") 
+        
+        # We'll first try to split on comma (,) for charge,mult.
+        charge_mult = geometry_section[0].split(",", 1)
+        # If we didn't get what we want, try on whitespace.
+        if len(charge_mult) != 2:
+            charge_mult = geometry_section[0].split(" ", 1)
+        
+        # Now try and set.
+        try:
+            self.charge = int(charge_mult[0])
+            self.multiplicity = int(charge_mult[1])
+        except Exception:
+            raise Digichem_exception("Unable to determine charge and multiplicity from '{}'".format(charge_mult))
+        
+        # The rest of the geometry section contains atoms.
+        if len(geometry_section) != 2 or geometry_section[1] == "":
+            raise Digichem_exception("Gaussian input file does not appear to contain any atoms")
+        
+        self.geometry = geometry_section[1]
+        
+        # Run a sanity check on the geometry format.
+        for geometry_line in self.geometry.split("\n"):
+            num_columns = len(geometry_line.split())
+            if num_columns > 4:
+                # We have too many columns?
+                raise Digichem_exception("Gaussian input file has too many columns ({}) in its geometry section".format(num_columns))
+                
+        
+        # And anything else.
+        self.additional_sections = sections[3:]
+        
+    @property
+    def xyz(self):
+        """
+        Get the geometry of this gaussian input file in XYZ format.
+        """
+        return "{}\n\n{}".format(len(self.geometry.split("\n")), self.geometry)
+

digichem/log.py

@@ -0,0 +1,179 @@
+import warnings
+import logging.handlers
+import sys
+import textwrap
+from subprocess import CalledProcessError
+
+from digichem.exception import Digichem_exception
+
+# The handler object digichem uses for logging.
+LOGGING_HANDLER = None
+
+# The name of the digichem logger, can be passed to logging.get_logger() to get the digichem logging object.
+LOGGER_NAME = "digichem"
+
+
+def init_logger(file_name = None, time = False):
+    """
+    Init the package wide logger.
+    
+    :param file_name: Optional file to write to. If not given, messages are logged to stderr.
+    :param time: Whether to include the time in the logging message.
+    """
+    global LOGGING_HANDLER
+    
+    logging.captureWarnings(True)
+    
+    logger = logging.getLogger(LOGGER_NAME)
+    warnings_logger = logging.getLogger("py.warnings")
+    
+    # Choose our handler.
+    if file_name is None:
+        # STDERR logging.
+        # The console handler, where we'll print most messages.
+        LOGGING_HANDLER = Handler(sys.stderr)
+    
+    else:
+        # File logging.
+        LOGGING_HANDLER = logging.handlers.RotatingFileHandler(file_name, maxBytes = 1024, backupCount = 5)
+        
+    # Handle everything.
+    LOGGING_HANDLER.setLevel(logging.DEBUG)
+    # Set its formatter.
+    var_formatter = Variable_formatter(logger, show_time = time, default_warning_formatter = warnings.formatwarning)
+    LOGGING_HANDLER.setFormatter(var_formatter)
+    
+    # Remove old handlers.
+    loggers = (logger, warnings_logger)
+    for log in loggers:
+        while len(log.handlers) > 0:
+            log.removeHandler(log.handlers[0])
+            
+        log.addHandler(LOGGING_HANDLER)
+    
+    # Add the handler.
+    warnings.formatwarning = var_formatter.formatWarning
+    
+    
+def set_logging_level(log_level, verbose = None):
+    """
+    Set the logging level of the digichem logger object.
+    
+    :param log_level: The base logging level as a string.
+    :param verbose: An integer which specifies how much to increase the logging level by. If verbose is zero (or None) then the logging level is determined only by log_level.
+    """
+    logger = get_logger()
+    
+    # Set from log_level first.
+    if log_level == "OFF":
+        logger.setLevel(60)
+    else:
+        logger.setLevel(log_level)
+    
+    # Now adjust with verbosity.
+    if verbose is not None:
+        # Set from verbosity.
+        new_level = logger.level - verbose * 10
+        
+        # Don't allow us to reach 0 (because this is actually 'UNSET').
+        if new_level <= 0:
+            new_level = 10
+        
+        # And set.
+        logger.setLevel(new_level)
+        
+#     # Adjust warnings if necessary.
+#     if logger.level == 10:
+#         warnings.simplefilter('always', DeprecationWarning)
+
+
+def get_logger():
+    """
+    Get the logger used by all parts of digichem.
+    """
+    return logging.getLogger(LOGGER_NAME)
+
+
+class Handler(logging.StreamHandler):
+    """
+    """
+    
+class Variable_formatter(logging.Formatter):
+    """
+    The logging formatter used by digichem, the format changes depending on a logger's log_level.
+    """
+    
+    # Different formatters for printing the message.
+    DEFAULT_FORMATTER = '%(levelname)s: %(message)s'
+    WHEN_FORMATTER = '%(asctime)s: %(levelname)s: %(message)s'
+    
+    # Format string for printing the date/time.
+    DATE_FORMAT = '%Y-%m-%d %H:%M:%S'
+    
+    def __init__(self, logger, show_time = False, *, default_warning_formatter):
+        super().__init__(
+            fmt = "digichem: " + (self.WHEN_FORMATTER if show_time else self.DEFAULT_FORMATTER),
+            datefmt = '%Y-%m-%d %H:%M:%S',
+            style = '%'
+        )
+        # Save our logger.
+        self.logger = logger
+        self.default_warning_formatter = default_warning_formatter
+        
+    def formatWarning(self, message, category, filename, lineno, line=None):
+        """
+        Format a warning (from the warnings module).
+        
+        :return: The formatted warning message.
+        """
+        if self.logger.getEffectiveLevel() > logging.DEBUG:
+            return "{}: {}".format(category.__name__, message)
+        else:
+            return self.default_warning_formatter(message, category, filename, lineno, line=None)
+                
+    def formatException(self, exc_info):
+        """
+        Format an exception.
+        
+        In Variable_formatter, how we do this depends on our log level.
+        
+        :return: The formatted exception.
+        """
+        if isinstance(exc_info[1], Digichem_exception) and self.logger.getEffectiveLevel() > logging.DEBUG:
+            return self.exception_to_str(exc_info[1])
+        else:
+            return textwrap.indent(super().formatException(exc_info), "  ")
+        
+    @classmethod
+    def process_output_to_str(self, process_exception):
+        """
+        Get additional descriptive text from a CalledProcessError exception.
+        
+        
+        """
+        output = ""
+        if process_exception.stdout is not None and process_exception.stdout != "\n":
+            output += "\n" + process_exception.stdout.strip()
+        if process_exception.stderr is not None and process_exception.stderr != "\n":
+            output += "\n" + process_exception.stderr.strip()
+        return output
+        
+    @classmethod
+    def exception_to_str(self, exception):
+        """
+        Recursively get a string representation of an exception.
+        
+        :return: A string representation of exception and any prior exceptions.
+        """
+        excstr = textwrap.indent("{}: {}".format(type(exception).__name__, exception), "\t")
+        
+        # If the exception is a CalledProcessError, we'll also append the stdout/stderr.
+        if isinstance(exception, CalledProcessError):
+            excstr += textwrap.indent(self.process_output_to_str(exception), "\t\t")
+        
+        if exception.__cause__ is not None:
+            excstr += "\n{}".format(self.exception_to_str(exception.__cause__))
+        elif exception.__context__ is not None and not exception.__suppress_context__:
+            excstr += "\n{}".format(self.exception_to_str(exception.__context__))
+        
+        return excstr

digichem/memory.py

@@ -0,0 +1,166 @@
+import numpy
+
+
+class Memory():
+    """
+    Class for storing memory-amounts.
+    """
+    
+    # The units that we know about.
+    UNITS = {
+        'TB': 1000000000000,
+        'GB': 1000000000,
+        'MB': 1000000,
+        'KB': 1000,
+         'B': 1
+        }
+    
+    # When outputting units, whether to separate the number and unit with a space.
+    SPACE_UNIT = False
+    
+    def __init__(self, value = None, print_decimal = False, round_decimal = True):
+        """
+        """
+        self.value = None
+        self.auto = value
+        self.print_decimal = print_decimal
+        self.round_decimal = round_decimal
+    
+    @classmethod
+    def from_units(self, value, units):
+        """
+        Create a memory object from a given amount of memory and a specified unit.
+        
+        :param value: The amount of memory.
+        :param units: The units of memory.
+        """
+        return self("{}{}".format(value, units))
+    
+    @property
+    def auto_units(self):
+        """
+        Get the amount of memory, as a tuple, using an automatically determined suffix.
+        """
+        # First, get an ordered list from our known units.
+        ordered_units = sorted(self.UNITS.items(), key = lambda item: item[1])
+        
+        # Now see where our number best fits (thanks numpy).
+        suffix_index = numpy.digitize((abs(self.value),), [ordered_unit[1] for ordered_unit in ordered_units])[0]
+        
+        # Wrap if we're out of bounds and convert to proper index.
+        if suffix_index == 0:
+            suffix_index += 0
+        elif suffix_index == len(ordered_units):
+            suffix_index -= 1
+        else:
+            suffix_index -= 1
+        
+        # Now check to see if we have a decimal part which is non zero.
+        while not self.print_decimal and suffix_index > -1 and (self.value / ordered_units[suffix_index][1]) % 1 != 0:
+            # Got a decimal part, use the next smallest unit.
+            suffix_index -= 1
+            
+        if suffix_index < 0:
+            # We ran out of units and couldn't remove our fraction.
+            if self.round_decimal:
+                # We're allowed to round our decimal away.
+                suffix_index = 0
+            else:
+                raise ValueError("Unable to represent memory value '{}'B as non decimal".format(self.value))
+        
+        # Now get our value in the correct units.
+        value = self.value / ordered_units[suffix_index][1]
+        if not self.print_decimal:
+            value = int(value)
+            
+        return (value, ordered_units[suffix_index][0])
+    
+    @property
+    def auto(self):
+        """
+        Get the amount of memory, as a string, using an automatically determined suffix.
+        """
+        value, units = self.auto_units
+        return "{}{}{}".format(value, " " if self.SPACE_UNIT else "", units)
+            
+        
+    @auto.setter
+    def auto(self, value):
+        """
+        Set the amount of memory, automatically determining the unit suffix (KB, MB, GB etc).
+        """
+        if isinstance(value, str):
+            # First, determine the suffix (if any).
+            suffix = None
+            for unit, amount in  sorted(self.UNITS.items(), key = lambda item: item[1], reverse = True):
+                if value.lower().endswith(unit.lower()):
+                    suffix = unit
+                    # This is a bit of a hack because all suffixes contain 'B' at the end.
+                    break
+                    
+            # Now remove the suffix (if there is one), convert to float and multiply by the value of suffix (to get bytes).
+            if suffix is not None:
+                value = float(value[:-len(suffix)]) * self.UNITS[suffix]
+        
+        # Convert to int (because not sure it makes sense to represent fractions of bytes) and store.
+        self.value = int(value)
+    
+    @property    
+    def MiB(self):
+        """
+        The value of this memory in MiB.
+        """
+        return round(self.value/1048576, None)
+    
+    @property    
+    def MB(self):
+        """
+        The value of this memory in MB.
+        """
+        return round(self.value/1000000, None)
+    
+    @property
+    def KiB(self):
+        """
+        The value of this memory in KiB.
+        """
+        return round(self.value/1024, None)
+    
+    @property
+    def KB(self):
+        """
+        The value of this memory in KB.
+        """
+        return round(self.value/1000, None)
+    
+    def __float__(self):
+        """
+        Floatify this memory amount (returning the number of bytes).
+        """
+        return float(self.value)
+    
+    def __int__(self):
+        """
+        Intify this memory amount (returning the number of bytes).
+        
+        In most cases, the int and float equivalents should be the same (because fractional bytes are not supported).
+        """
+        return int(self.value)
+    
+    def __str__(self):
+        """
+        Stringify this memory amount (returning the number of bytes) with an appropriate suffix.
+        """
+        return self.auto
+    
+    def __eq__(self, other):
+        return int(self) == other
+
+
+class Turbomole_memory(Memory):
+    """
+    A class for representing memory quantities in formats suitable for turbomole.
+    """
+    
+    # When outputting units, whether to separate the number and unit with a space.
+    SPACE_UNIT = False

digichem/misc/__init__.py

@@ -0,0 +1,4 @@
+from .layered_dict import Layered_dict
+from .time import date_to_string
+from .time import timedelta_to_string
+from .io import tail, smkdir, Multi_file_wrapper, cd

digichem/misc/argparse.py

@@ -0,0 +1,44 @@
+import argparse
+
+
+class Extend_action(argparse.Action):
+    """
+    An argparse action class to replace the "extend" action for versions of python (3.6 etc) that do not support it natively.
+    """
+
+    def __call__(self, parser, namespace, values, option_string = None):
+        """
+        """
+        try:
+            attr = getattr(namespace, self.dest)
+            
+        except AttributeError:
+            attr = []
+            setattr(namespace, self.dest, attr)
+            
+        attr.extend(values)
+
+# TODO: Unused.
+class List_grouper(argparse.Action):
+    """
+    Custom action class that groups lists together so we know in what order they were specified.
+    """    
+    
+    def __init__(self, option_strings, *args, **kwargs):
+        """
+        """
+        argparse.Action.__init__(self, option_strings, *args, **kwargs)
+        # We'll give ourself a name so we also group no matter which of our option_strings is used.
+        self.name = [name for name in option_strings if name[:2] == "--"]
+    
+    def __call__(self, parser, namespace, values, option_string=None):
+        """
+        """
+        grouped_list = {
+            'group': self,
+            'values': values
+        }
+        try:
+            getattr(namespace, self.dest).append(grouped_list)
+        except AttributeError:
+            setattr(namespace, self.dest, [grouped_list])

digichem/misc/base.py

@@ -0,0 +1,61 @@
+from itertools import chain, combinations
+
+def powerset(iterable):
+    "powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+def regular_range(median, number, spacing):
+    """
+    Generate a range of numbers with a given median and spacing.
+    """
+    if number % 2 == 0:
+        # Even number of peaks
+        peaks = []
+        for magnitude in range(int(number /2)):
+            peaks.append(median + (spacing /2 + magnitude * spacing))
+            peaks.append(median - (spacing /2 + magnitude * spacing))
+        
+    else:
+        # Odd number of peaks.
+        peaks = [median]
+        
+        for magnitude in range(int((number -1) /2)):
+            magnitude = magnitude+1
+            peaks.append(median + magnitude * spacing)
+            peaks.append(median - magnitude * spacing)
+        
+    return sorted(peaks)
+    
+
+def dict_list_index(dictionary, item):
+    "Find the key in a dictionary which contains the list which contains an item."
+    for dict_key, dict_value in dictionary.items():
+        if item in dict_value:
+            return dict_key
+    
+def dict_get(dict_obj, *fields):
+    """
+    Get a value from a nested dict of arbitrary depth.
+    
+    :param dict_obj: The nested dict.
+    :param fileds: Names of nested keys.
+    """
+    if len(fields) == 1:
+        return dict_obj[fields[0]]
+    else:    
+        return dict_get(dict_obj[fields[0]], *fields[1:])
+    
+def transpose(nested_list, dimensions):
+    """
+    Transpose a nested list, returning separate lists of the nested items.
+    
+    eg, transpose([(1, "a"), (2, "b"), (3, "c")])
+    -> [[1, 2, 3], ["a", "b", "c"] 
+    """
+    if len(nested_list) == 0:
+        return [list() for i in range(dimensions)]
+    
+    else:
+        return list(map(list, zip(*nested_list)))
+