patme 0.4.4__py3-none-any.whl

patme/service/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2022 German Aerospace Center (DLR)
+#
+# SPDX-License-Identifier: MIT
+
+"""
+The modules of this package support program runs with a logger, exceptions, duration checking etc.
+"""

patme/service/decorators.py

@@ -0,0 +1,85 @@
+# SPDX-FileCopyrightText: 2022 German Aerospace Center (DLR)
+#
+# SPDX-License-Identifier: MIT
+
+"""
+Created on 13.07.2016
+
+@author: schu_a1
+"""
+import cProfile
+import functools
+import hashlib
+import pickle
+
+from patme.service.logger import log
+
+
+def inheritDocStringFromFunction(fromFunction):
+    """For the original implementation refer to https://groups.google.com/forum/#!msg/comp.lang.python/HkB1uhDcvdk/lWzWtPy09yYJ"""
+
+    def docstringInheritingDecorator(toFunction):
+        toFunction.__doc__ = fromFunction.__doc__
+        return toFunction
+
+    return docstringInheritingDecorator
+
+
+def memoize(obj):
+    """Caches a function's return value each time it is called.
+    If called later with the same arguments, the cached value is returned
+    """
+    cache = obj.cache = {}
+
+    @functools.wraps(obj)
+    def memoizer(*args, **kwargs):
+        # =======================================================================
+        # calculate key
+        # =======================================================================
+        try:
+            pickleString = pickle.dumps((args, kwargs), protocol=0)
+            key = hashlib.sha256(pickleString).hexdigest()
+        except AttributeError:  # if items can not be pickled
+            try:
+                key = args + tuple(kwargs.items())
+                hash(key)  # try to hash key
+            except TypeError:  # if args or kwargs can not be hashed
+                log.debug("Args and kwargs can not be cached. Calculating function each time.")
+                return obj(*args, **kwargs)
+        # =======================================================================
+        # call function or use cached samples and return them
+        # =======================================================================
+        if key not in cache:
+            cache[key] = obj(*args, **kwargs)
+        else:
+            log.debug("use cached results for these args and kwargs: {}".format((args, kwargs)))
+        return cache[key]
+
+    return memoizer
+
+
+def avoidDublicate(obj):
+    """Returns None, if this input was already processed"""
+    cache = obj.cache = {}
+
+    @functools.wraps(obj)
+    def memoizer(*args, **kwargs):
+        key = repr(args) + str(kwargs)
+        if key not in cache:
+            cache[key] = True
+            obj(*args, **kwargs)
+        else:
+            return
+
+    return memoizer
+
+
+def returnNoneOnFail(obj):
+    @functools.wraps(obj)
+    def returnFunc(*args, **kwargs):
+        try:
+            return obj(*args, **kwargs)
+        except:
+            return None
+
+    return returnFunc

patme/service/duration.py

@@ -0,0 +1,96 @@
+# Copyright (C) 2013 Deutsches Zentrum fuer Luft- und Raumfahrt(DLR, German Aerospace Center) <www.dlr.de>
+# SPDX-FileCopyrightText: 2022 German Aerospace Center (DLR)
+#
+# SPDX-License-Identifier: MIT
+
+"""
+Measurement of the duration for executing functions and methods and within methods.
+
+Usage for **functions and methods**::
+
+    from patme.service.duration import Duration
+
+    duration = Duration()
+    @duration.timeit
+    def testfunc():
+        a='do something'
+
+Usage **within functions/methods**::
+
+    from patme.service.duration import measureDuration
+
+    def testfunc():
+        with measureDuration():
+            a='do something'
+
+The **logLevel** of all Duration instances may be changed with ``setDurationLogLevel``:
+
+>>> from patme.service.logger import log
+>>> from patme.service.duration import setDurationLogLevel
+>>> setDurationLogLevel(log.logLevel + 1)
+
+
+"""
+
+import logging
+import time
+from contextlib import contextmanager
+
+from patme.service.logger import log
+
+
+class Duration:
+    """
+    classdocs
+    """
+
+    def __init__(self):
+        """
+        Constructor
+        """
+
+    def timeit(self, method):
+        global _durationLogLevel
+
+        def timed(*args, **kw):
+            ts = time.time()
+            result = method(*args, **kw)
+            te = time.time()
+            log.log(
+                _durationLogLevel,
+                f"Duration for execution of method or class {method.__name__!r}: {te - ts:4.4f} sec",
+            )
+            return result
+
+        return timed
+
+
+_durationLogLevel = log.logLevel + 1
+logging.addLevelName(_durationLogLevel, "TIME")
+
+
+def setDurationLogLevel(logLevel):
+    """Sets the log level to the logging module and the Duration class"""
+    global _durationLogLevel
+    logging.addLevelName(logLevel, "TIME")
+    _durationLogLevel = logLevel
+
+
+def getDurationLogLevel():
+    """Returns the duration log level"""
+    return _durationLogLevel
+
+
+@contextmanager
+def measureDuration():
+    """doc"""
+    start = time.time()
+    yield
+    end = time.time()
+    print("Duration: %2.5f" % (end - start))
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod(verbose=True)

patme/service/exceptionhook.py

@@ -0,0 +1,104 @@
+# Copyright (C) 2013 Deutsches Zentrum fuer Luft- und Raumfahrt(DLR, German Aerospace Center) <www.dlr.de>
+# SPDX-FileCopyrightText: 2022 German Aerospace Center (DLR)
+#
+# SPDX-License-Identifier: MIT
+
+"""
+In order to have better readable error messages for users, the standard exception output is modified.
+
+This exception hook prints the exceptions message in a nice format without traceback. The console output and
+traceback are written to a file. The exception hook is set in place using the redirectExceptions function.
+
+Usage::
+
+    from patme.service.exceptionhook import redirectExceptions
+    redirectExceptions(progName='MyProg', ver='0.1.0')
+    raise Exception('foobar')
+
+Output::
+
+    ################################################################################
+    Error: Program "MyProg" stopped due to an exception
+    2020-05-04, 18:20:49
+    Version: 0.1.0
+    Error log file at: C:\\eclipse_projects\\patme\\src\\patme\\service\\err.log
+    Error message:
+    --------------------------------------------------------------------------------
+"""
+
+import io
+import os
+import sys
+import time
+import traceback
+
+from patme.service.logger import log
+
+errorLogFilename = None
+programName = None
+version = None
+
+
+def redirectExceptions(errorLogFile="err.log", toDir=None, progName=None, ver=None):
+    """introduces the a nicer exception hook into this python process
+
+    :param errorLogFile: File containing the exception message including the traceback
+    :param toDir: Directory of the error log file.
+    :param progName: name of the program
+    :param ver: version of the program"""
+    if toDir is not None:
+        errorLogFile = os.path.join(toDir, os.path.basename(errorLogFile))
+
+    global errorLogFilename, programName, version
+    errorLogFilename = errorLogFile
+    programName = progName
+    version = ver
+
+    # set system exception hook
+    sys.excepthook = excepthook
+
+
+def excepthook(excType, excValue, tracebackobj):
+    """
+    function to catch exceptions. It writes a log to errorLogFilename.
+
+    :param excType: exception type
+    :param excValue: exception value
+    :param tracebackobj: traceback object
+    """
+    separator = "-" * 80
+    separatorTop = "#" * 80
+
+    versionInfo = "" if version is None else "Version: " + version + "\n"
+    name = "" if programName is None else ' "' + programName + '"'
+    logFileNotice = f"Error log file at: {os.path.abspath(errorLogFilename)}"
+    timeString = time.strftime("%Y-%m-%d, %H:%M:%S")
+    notice = f"Error: Program{name} stopped due to an exception"
+
+    tbinfofile = io.StringIO()
+    traceback.print_tb(tracebackobj, None, tbinfofile)
+    tbinfofile.seek(0)
+    tbinfo = "Traceback:\n" + tbinfofile.read()
+    errmsg = f"{str(excType)}: \n{str(excValue)}"
+    sections = [
+        separatorTop,
+        notice,
+        timeString,
+        versionInfo + logFileNotice,
+        "Error message:",
+        separator,
+        errmsg,
+        separator,
+        tbinfo,
+    ]
+    msg = "\n".join(sections) + "\n" * 4
+    if errorLogFilename:
+        try:
+            with open(os.path.normpath(errorLogFilename), "a") as f:
+                f.write(msg)
+        except OSError:
+            pass
+    log.end()
+    sys.stdout.flush()
+    sys.stderr.write("\n".join(sections[:8]) + "\n\n")
+    sys.stderr.flush()

patme/service/exceptions.py

@@ -0,0 +1,36 @@
+# SPDX-FileCopyrightText: 2022 German Aerospace Center (DLR)
+#
+# SPDX-License-Identifier: MIT
+
+"""
+Custom exceptions in order to specialize exception names and to catch tool-specific exceptions only.
+"""
+
+
+class CustomException(Exception):
+    """This class defines and abstract exception class so that customized exceptions
+    can be inherited."""
+
+    def __init__(self, value):
+        """doc"""
+        self.value = value
+
+    def __str__(self):
+        """Returning the error message"""
+        return repr(self.value)
+
+
+class InternalError(CustomException):
+    """classdocs"""
+
+
+class ImproperParameterError(CustomException):
+    """classdocs"""
+
+
+class DelisSshError(CustomException):
+    """classdocs"""
+
+
+class GeometryError(CustomException):
+    """classdocs"""

patme/service/io/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2022 German Aerospace Center (DLR)
+#
+# SPDX-License-Identifier: MIT

patme/service/io/basewriter.py

@@ -0,0 +1,122 @@
+# Copyright (C) 2013 Deutsches Zentrum fuer Luft- und Raumfahrt(DLR, German Aerospace Center) <www.dlr.de>
+# SPDX-FileCopyrightText: 2022 German Aerospace Center (DLR)
+#
+# SPDX-License-Identifier: MIT
+
+"""
+
+This module contains a generic writer to create arbitrary-based output. All Writers shall
+contain the same public methods.
+"""
+import os
+import traceback
+from io import StringIO
+
+from patme.service.logger import log
+
+
+class GenericWriter:
+    """Abstract geometry writer class"""
+
+    commentChar = ""
+
+    def __init__(self, filename="", **kwargs):
+        """doc"""
+        self.filename = filename
+        self.lineBuffer = StringIO()
+
+    def __enter__(self):
+        """doc"""
+        fObj = getattr(self, "f", None)
+        logFunction = log.debug
+        if not fObj:
+            try:
+                self.lineBuffer = StringIO()
+                mode, descr = ("w", "") if getattr(self, "overwriteFile", True) else ("a", "re")
+                logFunction(f"{descr}opening file {self.filename}")
+                self.f = open(self.filename, mode)
+            except:
+                self.close()
+                raise
+        elif fObj.closed:
+            try:
+                logFunction(f"reopening file {self.filename}")
+                self.lineBuffer = StringIO()
+                self.f = open(self.filename, "a")
+            except:
+                self.close()
+                raise
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """doc"""
+        if exc_type:
+            traceback.print_exception(exc_type, exc_val, exc_tb)
+        else:
+            self.end()
+
+    def preamble(self, *args, **kwargs):
+        """Doing writer-dependend initialization work"""
+        raise NotImplementedError("This is an abstract method.")
+
+    def end(self):
+        """Writer-dependent finalizing of the writer."""
+        raise NotImplementedError("This is an abstract method.")
+
+    def includeOtherFile(self, otherFile):
+        """Writer-dependent including of other files into current writer instance."""
+        raise NotImplementedError("This is an abstract method.")
+
+    def close(self):
+        """doc"""
+        try:
+            # write line buffer content to file
+            self.f.write(self.lineBuffer.getvalue())
+        except:
+            log.debug(f'Filedescriptor of writer "{self}" is not open! Could not write line')
+
+        if hasattr(self, "f") and not self.f.closed:
+            log.debug(f"closing file {self.filename}")
+            self.f.close()
+
+        self.lineBuffer.close()  # reset buffer
+
+    def save(self):
+        """Saving the writer output to a writer dependent path."""
+        self._save()
+
+    def functionPreamble(self, functionName="", sketchNumber=""):
+        """Writes preamble of a function: like Subroutine ... or function ..."""
+
+    def commentHeadline(self, comment="", printTime=False):
+        """Big comment"""
+
+    def comment(self, comment=""):
+        self.writeRow(self.commentChar + comment)
+
+    def printTime(self, outString):
+        """This method makes the output language print the"""
+
+    def writeRows(self, rows):
+        """doc"""
+        self.writeRow("\n".join(rows))
+
+    def writeRow(self, outString=""):
+        """doc"""
+        self.lineBuffer.write(outString + "\n")
+
+    def orientationPoint(self, point):
+        """is intended for ansys to write the orientation point of beams
+
+        Other geometry writer do not need this point, thus this method omits everything
+        """
+
+    def _getRunDir(self):
+        """doc"""
+        if self.filename:
+            pathName = os.path.dirname(os.path.abspath(self.filename))
+            if pathName != "":
+                return pathName
+        return "."
+
+    runDir = property(fget=_getRunDir)