Merge branch '2.7_stack_context' of github.com:Ultimaker/Uranium into 2.7

Author: nallath

UM/Backend/Backend.py

@@ -27,6 +27,7 @@ class BackendState(IntEnum):
     Error = 4
     Disabled = 5
 
+
 ##      Base class for any backend communication (separate piece of software).
 #       It makes use of the Socket class from libArcus for the actual communication bits.
 #       The message_handlers dict should be filled with string (full name of proto message), function pairs.
@@ -71,7 +72,7 @@ def startEngine(self):
             self._process = self._runEngineProcess(command)
             if self._process is None: #Failed to start engine.
                 return
-            Logger.log("i", "Started engine process: %s" % (self.getEngineCommand()[0]))
+            Logger.log("i", "Started engine process: %s", self.getEngineCommand()[0])
             self._backendLog(bytes("Calling engine with: %s\n" % self.getEngineCommand(), "utf-8"))
             t = threading.Thread(target = self._storeOutputToLogThread, args = (self._process.stdout,))
             t.daemon = True
@@ -80,7 +81,7 @@ def startEngine(self):
             t.daemon = True
             t.start()
         except FileNotFoundError as e:
-            Logger.log("e", "Unable to find backend executable: %s" % (self.getEngineCommand()[0]))
+            Logger.log("e", "Unable to find backend executable: %s", self.getEngineCommand()[0])
 
     def close(self):
         if self._socket:

UM/Settings/ContainerRegistry.py

@@ -567,7 +567,7 @@ def isDirty(self) -> bool:
     def isReadOnly(self) -> bool:
         return True
 
-    def getProperty(self, key, property_name):
+    def getProperty(self, key, property_name, context = None):
         return None
 
     def setProperty(self, key, property_name, property_value, container = None, set_from_cache = False):

UM/Settings/ContainerStack.py

@@ -14,6 +14,7 @@
 from UM.MimeTypeDatabase import MimeTypeDatabase, MimeType
 from UM.Settings.DefinitionContainer import DefinitionContainer #For getting all definitions in this stack.
 from UM.Settings.Interfaces import ContainerInterface, ContainerRegistryInterface
+from UM.Settings.PropertyEvaluationContext import PropertyEvaluationContext
 from UM.Settings.SettingFunction import SettingFunction
 from UM.Settings.Validator import ValidatorState
 
@@ -194,10 +195,14 @@ def setDirty(self, dirty: bool) -> None:
     #   Note that if the property value is a function, this method will return the
     #   result of evaluating that property with the current stack. If you need the
     #   actual function, use getRawProperty()
-    def getProperty(self, key: str, property_name: str):
+    def getProperty(self, key: str, property_name: str, context: Optional[PropertyEvaluationContext] = None):
         value = self.getRawProperty(key, property_name)
         if isinstance(value, SettingFunction):
-            return value(self)
+            if context is not None:
+                context.pushContainer(self)
+            value = value(self, context)
+            if context is not None:
+                context.popContainer()
 
         return value
 

UM/Settings/DefinitionContainer.py

@@ -167,7 +167,7 @@ def getMetaDataEntry(self, entry, default = None):
     ##  \copydoc ContainerInterface::getProperty
     #
     #   Reimplemented from ContainerInterface.
-    def getProperty(self, key, property_name):
+    def getProperty(self, key, property_name, context = None):
         definition = self._getDefinition(key)
         if not definition:
             return None

UM/Settings/InstanceContainer.py

@@ -257,7 +257,7 @@ def setDirty(self, dirty):
     ##  \copydoc ContainerInterface::getProperty
     #
     #   Reimplemented from ContainerInterface
-    def getProperty(self, key, property_name):
+    def getProperty(self, key, property_name, context = None):
         self._instantiateCachedValues()
         if key in self._instances:
             try:

UM/Settings/Interfaces.py

@@ -5,6 +5,7 @@
 
 import UM.Decorators
 from UM.Signal import Signal
+from UM.Settings.PropertyEvaluationContext import PropertyEvaluationContext
 
 
 ##  Shared interface between setting container types
@@ -62,7 +63,7 @@ def getMetaDataEntry(self, entry: str, default: Any = None) -> Any:
     #   \param name \type{string} The name of the property to retrieve.
     #
     #   \return The specified property value of the container item corresponding to key, or None if not found.
-    def getProperty(self, key: str, property_name: str) -> Any:
+    def getProperty(self, key: str, property_name: str, context: Optional[PropertyEvaluationContext] = None) -> Any:
         pass
 
     ##  Get whether the container item has a specific property.

UM/Settings/Models/SettingPropertyProvider.py

@@ -275,13 +275,17 @@ def _onPropertiesChanged(self, key, property_names):
                 self.isValueUsedChanged.emit()
             return
 
+        has_values_changed = False
         for property_name in property_names:
             if property_name not in self._watched_properties:
                 continue
 
+            has_values_changed = True
             self._property_map.insert(property_name, self._getPropertyValue(property_name))
 
         self._updateStackLevels()
+        if has_values_changed:
+            self.propertiesChanged.emit()
 
     def _update(self, container = None):
         if not self._stack or not self._watched_properties or not self._key:

UM/Settings/PropertyEvaluationContext.py

@@ -0,0 +1,28 @@
+# Copyright (c) 2017 Ultimaker B.V.
+# Uranium is released under the terms of the AGPLv3 or higher.
+
+from collections import deque
+
+
+##  Context for evaluating a property value
+#   It contains:
+#     1. a stack of containers during the evaluation in the function call stack fashion
+#     2. a context dictionary which contains all the current context
+#
+class PropertyEvaluationContext:
+
+    def __init__(self, source_stack = None):
+        self.stack_of_containers = deque()
+        if source_stack is not None:
+            self.stack_of_containers.append(source_stack)
+        self.context = {}
+
+    def rootStack(self):
+        if self.stack_of_containers:
+            return self.stack_of_containers[0]
+
+    def pushContainer(self, container):
+        self.stack_of_containers.append(container)
+
+    def popContainer(self):
+        return self.stack_of_containers.pop()

UM/Settings/SettingFunction.py

@@ -3,9 +3,10 @@
 
 import ast
 import math # Imported here so it can be used easily by the setting functions.
-from typing import Any, Dict, Callable, Set, FrozenSet, NamedTuple
+from typing import Any, Dict, Callable, Set, FrozenSet, NamedTuple, Optional
 
 from UM.Settings.Interfaces import ContainerInterface
+from UM.Settings.PropertyEvaluationContext import PropertyEvaluationContext
 from UM.Logger import Logger
 
 MYPY = False
@@ -54,16 +55,19 @@ def __init__(self, code: str) -> None:
             Logger.log("e", "Exception in function ({0}) for setting: {1}".format(str(e), self._code))
 
     ##  Call the actual function to calculate the value.
-    def __call__(self, value_provider: ContainerInterface) -> Any:
+    def __call__(self, value_provider: ContainerInterface, context: Optional[PropertyEvaluationContext] = None) -> Any:
         if not value_provider:
             return None
 
         if not self._valid:
             return None
 
         locals = {} # type: Dict[str, Any]
+        # if there is a context, evaluate the values from the perspective of the original caller
+        if context is not None:
+            value_provider = context.rootStack()
         for name in self._used_values:
-            value = value_provider.getProperty(name, "value")
+            value = value_provider.getProperty(name, "value", context)
             if value is None:
                 continue
 

UM/Settings/Validator.py

@@ -2,9 +2,10 @@
 # Uranium is released under the terms of the AGPLv3 or higher.
 
 from enum import Enum
-from typing import Any
+from typing import Any, Optional
 
 from UM.Settings.Interfaces import ContainerInterface
+from UM.Settings.PropertyEvaluationContext import PropertyEvaluationContext
 from UM.Logger import Logger
 
 MYPY = False
@@ -39,7 +40,7 @@ def __init__(self, key: str) -> None:
         self._key = key  # type: str
 
     ##  Perform the actual validation.
-    def __call__(self, value_provider: ContainerInterface) -> Any:
+    def __call__(self, value_provider: ContainerInterface, context: Optional[PropertyEvaluationContext] = None) -> Any:
         if not value_provider:
             return
 
@@ -53,6 +54,9 @@ def __call__(self, value_provider: ContainerInterface) -> Any:
             if minimum is not None and maximum is not None and minimum > maximum:
                 raise ValueError("Cannot validate a state of setting {0} with minimum > maximum".format(self._key))
 
+            if context is not None:
+                value_provider = context.rootStack()
+
             value = value_provider.getProperty(self._key, "value")
             if value is None or value != value:
                 raise ValueError("Cannot validate None, NaN or similar values in setting {0}, actual value: {1}".format(self._key, value))