Added Common folder not included in last commit

Ezequiel Torres · Ezequiel Torres · commit 7f9ef92b9549 · 2017-03-22T12:00:50.000-03:00
diff --git a/MLC/GUI/Common/QtWaitingSpinner.py b/MLC/GUI/Common/QtWaitingSpinner.py
@@ -0,0 +1,222 @@
+"""
+The MIT License (MIT)
+
+Copyright (c) 2012-2014 Alexander Turkin
+Copyright (c) 2014 William Hallatt
+Copyright (c) 2015 Jacob Dawid
+Copyright (c) 2016 Luca Weiss
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import math
+
+from PyQt5.QtCore import *
+from PyQt5.QtGui import *
+from PyQt5.QtWidgets import *
+
+
+class QtWaitingSpinner(QWidget):
+
+    def __init__(self, parent, centerOnParent=True, disableParentWhenSpinning=False, modality=Qt.NonModal):
+        QWidget.__init__(self, parent)
+
+        self._centerOnParent = centerOnParent
+        self._disableParentWhenSpinning = disableParentWhenSpinning
+
+        # WAS IN initialize()
+        self._color = QColor(Qt.black)
+        self._roundness = 100.0
+        self._minimumTrailOpacity = 3.14159265358979323846
+        self._trailFadePercentage = 80.0
+        self._revolutionsPerSecond = 1.57079632679489661923
+        self._numberOfLines = 20
+        self._lineLength = 10
+        self._lineWidth = 2
+        self._innerRadius = 10
+        self._currentCounter = 0
+        self._isSpinning = False
+
+        self._timer = QTimer(self)
+        self._timer.timeout.connect(self.rotate)
+        self.updateSize()
+        self.updateTimer()
+        self.hide()
+        # END initialize()
+
+        self.setWindowModality(modality)
+        self.setAttribute(Qt.WA_TranslucentBackground)
+
+    def paintEvent(self, QPaintEvent):
+        self.updatePosition()
+        painter = QPainter(self)
+        painter.fillRect(self.rect(), Qt.transparent)
+        painter.setRenderHint(QPainter.Antialiasing, True)
+
+        if self._currentCounter >= self._numberOfLines:
+            self._currentCounter = 0
+
+        painter.setPen(Qt.NoPen)
+        for i in range(0, self._numberOfLines):
+            painter.save()
+            painter.translate(
+                self._innerRadius + self._lineLength, self._innerRadius + self._lineLength)
+            rotateAngle = float(360 * i) / float(self._numberOfLines)
+            painter.rotate(rotateAngle)
+            painter.translate(self._innerRadius, 0)
+            distance = self.lineCountDistanceFromPrimary(
+                i, self._currentCounter, self._numberOfLines)
+            color = self.currentLineColor(
+                distance, self._numberOfLines, self._trailFadePercentage,
+                self._minimumTrailOpacity, self._color)
+            painter.setBrush(color)
+            painter.drawRoundedRect(
+                QRect(0, -self._lineWidth / 2, self._lineLength,
+                      self._lineWidth), self._roundness,
+                self._roundness, Qt.RelativeSize)
+            painter.restore()
+
+    def start(self):
+        self.updatePosition()
+        self._isSpinning = True
+        self.show()
+
+        if self.parentWidget and self._disableParentWhenSpinning:
+            self.parentWidget().setEnabled(False)
+
+        if not self._timer.isActive():
+            self._timer.start()
+            self._currentCounter = 0
+
+    def stop(self):
+        self._isSpinning = False
+        self.hide()
+
+        if self.parentWidget() and self._disableParentWhenSpinning:
+            self.parentWidget().setEnabled(True)
+
+        if self._timer.isActive():
+            self._timer.stop()
+            self._currentCounter = 0
+
+    def setNumberOfLines(self, lines):
+        self._numberOfLines = lines
+        self._currentCounter = 0
+        self.updateTimer()
+
+    def setLineLength(self, length):
+        self._lineLength = length
+        self.updateSize()
+
+    def setLineWidth(self, width):
+        self._lineWidth = width
+        self.updateSize()
+
+    def setInnerRadius(self, radius):
+        self._innerRadius = radius
+        self.updateSize()
+
+    def color(self):
+        return self._color
+
+    def roundness(self):
+        return self._roundness
+
+    def minimumTrailOpacity(self):
+        return self._minimumTrailOpacity
+
+    def trailFadePercentage(self):
+        return self._trailFadePercentage
+
+    def revolutionsPersSecond(self):
+        return self._revolutionsPerSecond
+
+    def numberOfLines(self):
+        return self._numberOfLines
+
+    def lineLength(self):
+        return self._lineLength
+
+    def lineWidth(self):
+        return self._lineWidth
+
+    def innerRadius(self):
+        return self._innerRadius
+
+    def isSpinning(self):
+        return self._isSpinning
+
+    def setRoundness(self, roundness):
+        self._roundness = max(0.0, min(100.0, roundness))
+
+    def setColor(self, color=Qt.black):
+        self._color = QColor(color)
+
+    def setRevolutionsPerSecond(self, revolutionsPerSecond):
+        self._revolutionsPerSecond = revolutionsPerSecond
+        self.updateTimer()
+
+    def setTrailFadePercentage(self, trail):
+        self._trailFadePercentage = trail
+
+    def setMinimumTrailOpacity(self, minimumTrailOpacity):
+        self._minimumTrailOpacity = minimumTrailOpacity
+
+    def rotate(self):
+        self._currentCounter += 1
+        if self._currentCounter >= self._numberOfLines:
+            self._currentCounter = 0
+        self.update()
+
+    def updateSize(self):
+        size = (self._innerRadius + self._lineLength) * 2
+        self.setFixedSize(size, size)
+
+    def updateTimer(self):
+        self._timer.setInterval(
+            1000 / (self._numberOfLines * self._revolutionsPerSecond))
+
+    def updatePosition(self):
+        if self.parentWidget() and self._centerOnParent:
+            self.move(self.parentWidget().width() / 2 - self.width() / 2,
+                      self.parentWidget().height() / 2 - self.height() / 2)
+
+    def lineCountDistanceFromPrimary(self, current, primary, totalNrOfLines):
+        distance = primary - current
+        if distance < 0:
+            distance += totalNrOfLines
+        return distance
+
+    def currentLineColor(self, countDistance, totalNrOfLines, trailFadePerc, minOpacity, colorinput):
+        color = QColor(colorinput)
+        if countDistance == 0:
+            return color
+        minAlphaF = minOpacity / 100.0
+        distanceThreshold = int(
+            math.ceil((totalNrOfLines - 1) * trailFadePerc / 100.0))
+        if countDistance > distanceThreshold:
+            color.setAlphaF(minAlphaF)
+        else:
+            alphaDiff = color.alphaF() - minAlphaF
+            gradient = alphaDiff / float(distanceThreshold + 1)
+            resultAlpha = color.alphaF() - gradient * countDistance
+            # If alpha is out of bounds, clip it.
+            resultAlpha = min(1.0, max(0.0, resultAlpha))
+            color.setAlphaF(resultAlpha)
+        return color
diff --git a/MLC/GUI/Common/__init__.py b/MLC/GUI/Common/__init__.py
diff --git a/MLC/GUI/Common/util.py b/MLC/GUI/Common/util.py
@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*-
+# MLC (Machine Learning Control): A genetic algorithm library to solve chaotic problems
+# Copyright (C) 2015-2017, Thomas Duriez (thomas.duriez@gmail.com)
+# Copyright (C) 2015, Adrian Durán (adrianmdu@gmail.com)
+# Copyright (C) 2015-2017, Ezequiel Torres Feyuk (ezequiel.torresfeyuk@gmail.com)
+# Copyright (C) 2016-2017, Marco Germano Zbrun (marco.germano@intraway.com)
+# Copyright (C) 2016-2017, Raúl Lopez Skuba (raulopez0@gmail.com)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>
+
+import os
+import sys
+import traceback
+
+from MLC.Common.LispTreeExpr.LispTreeExpr import LispTreeExpr
+from MLC.Common.LispTreeExpr.LispTreeExpr import ExprException
+from MLC.Common.PreevaluationManager import PreevaluationManager
+from MLC.individual.Individual import Individual
+from MLC.Log.log import get_gui_logger
+from MLC.Population.Evaluation.EvaluatorFactory import EvaluatorFactory
+from PyQt5.QtWidgets import QMessageBox
+
+logger = get_gui_logger()
+
+"""
+Utilities functions used in more than one class or python module
+"""
+
+
+def test_individual_value(parent, experiment_name, log_prefix, indiv_value, config):
+    try:
+        """
+        Evaluate an individual in order to check its correctness. Handle Exceptions
+        """
+        LispTreeExpr.check_expression(indiv_value)
+        individual = Individual.generate(config=config,
+                                         rhs_value=indiv_value)
+        callback = EvaluatorFactory.get_callback()
+        return callback.cost(individual)
+    except ExprException, err:
+        # Print the error message returned in the exception,
+        # removing the prefix ([EXPR_EXCEPTION]])
+        QMessageBox.critical(parent,
+                             "Invalid Individual",
+                             "Individual inserted is not well-formed. "
+                             "Error Msg: {0}"
+                             .format(err.message[err.message.find(']') + 2:]))
+        logger.error("{0} Experiment {1} - "
+                     "Individual inserted is not well-formed. "
+                     "Error Msg: {2}"
+                     .format(log_prefix, experiment_name,
+                             err.message[err.message.find(']') + 2:]))
+    except Exception, err:
+        QMessageBox.critical(parent,
+                             "Invalid Evaluation Script",
+                             "Check the evaluation script to be correct. "
+                             "Error Msg: {0}. \n Traceback: {1}"
+                             .format(err, traceback.format_exc()))
+
+        logger.error("{0} Experiment {1} - "
+                     "Individual inserted is not a valid individual. "
+                     "Check the evaluation script to be correct. "
+                     "Error Msg: {2}. Traceback:\n{3}"
+                     .format(log_prefix, experiment_name, err, traceback.format_exc()))
+
+    return None
+
+
+def check_individual_value(parent, experiment_name, log_prefix, indiv_value, nodialog=False):
+    try:
+        """
+        Evaluate an individual in order to check its correctness. Handle Exceptions
+        """
+        LispTreeExpr.check_expression(indiv_value)
+        return True
+    except ExprException, err:
+        # Print the error message returned in the exception,
+        # removing the prefix ([EXPR_EXCEPTION]])
+        if not nodialog:
+            QMessageBox.critical(parent,
+                                 "Invalid Individsual",
+                                 "Individual inserted is not well-formed. "
+                                 "Error Msg: {0}"
+                                 .format(err.message[err.message.find(']') + 2:]))
+        logger.error("{0} Experiment {1} - "
+                     "Individual inserted is not well-formed. "
+                     "Error Msg: {2}"
+                     .format(log_prefix, experiment_name,
+                             err.message[err.message.find(']') + 2:]))
+    return False
+
+
+def check_if_indiv_pass_preevaluation(parent, experiment_name, log_prefix, indiv_value, config):
+    try:
+        """
+        Evaluate an individual in order to check its correctness. Handle Exceptions
+        """
+        LispTreeExpr.check_expression(indiv_value)
+        individual = Individual.generate(config=config,
+                                         rhs_value=indiv_value)
+        callback = PreevaluationManager.get_callback()
+        return callback.preev(individual)
+    except ExprException, err:
+        # Print the error message returned in the exception,
+        # removing the prefix ([EXPR_EXCEPTION]])
+        QMessageBox.critical(parent,
+                             "Invalid Individual",
+                             "Individual inserted is not well-formed. "
+                             "Error Msg: {0}"
+                             .format(err.message[err.message.find(']') + 2:]))
+        logger.error("{0} Experiment {1} - "
+                     "Individual inserted is not well-formed. "
+                     "Error Msg: {2}"
+                     .format(log_prefix, experiment_name,
+                             err.message[err.message.find(']') + 2:]))
+    except Exception, err:
+        QMessageBox.critical(parent,
+                             "Invalid Evaluation Script",
+                             "Check the evaluation script to be correct. "
+                             "Error Msg: {0}.".format(err))
+        logger.error("{0} Experiment {1} - "
+                     "Individual inserted is not a valid individual. "
+                     "Check the evaluation script to be correct. "
+                     "Error Msg: {2}."
+                     .format(log_prefix, experiment_name, err))
+
+    return None
+
+
+def add_permissions_to_file(filepath, permissions, user_password=None):
+    # Create the command to execute
+    cmd = 'chmod {0} {1}'.format(permissions, filepath)
+    logger.info('Proceed to give {0} permissions to file {1}'.format(permissions, filepath))
+    if user_password:
+        cmd_error_code = os.system('echo %s |sudo -S %s' % (user_password, cmd))
+        # Erase the passwd stored, so sudo obliged us to insert it again
+        os.system('sudo -K')
+        return cmd_error_code == 0
+    else:
+        return os.system(cmd) == 0
