Refinement Pragmatics

goald/quality/pragmatic/model/qualityConstraint.py

@@ -6,6 +6,9 @@ def __init__(self, context, metric, value, comparison):
         self.value = value
         self.comparison = comparison
 
+    def getApplicableContext(self):
+        return self.aplicableContext
+
     def abidesByQC(self, value, metric):
         #if metric in self.metric:
         if not self.compare(value):
@@ -49,3 +52,4 @@ def stricterQC(self, qualityConstraint):
                 return qualityConstraint
 
         return None
+

goald/quality/pragmatic/model/refinement.py

@@ -5,24 +5,62 @@ def __init__(self):
         self.TASK = 2
         self.DELEGATION = 3
 
-        self.aplicableContext = {}
-        self.nonAplicableContexts = {}
+        self.aplicableContext = []
+        self.nonAplicableContexts = []
 
         self.isOrDecomposition = False
 
-        self.dependencies = {}
+        self.dependencies = []
 
         self.identifier = ""
 
-        self.aplicableContext.add(self.aplicableContext,None)
+        self.aplicableContext.append(None)
 
     def addApplicableContext(self,context):
-        if self.aplicableContext:
-            self.aplicableContext.popitem(None)
+        if None in self.aplicableContext:
+            self.aplicableContext.remove(None)
         else:
-            self.aplicableContext[context] += context
+            self.aplicableContext.append(context)
 
-    def addNonAplicableContext(context):
-        self.nonAplicableContexts.add(context)
+    def addNonAplicableContext(self,context):
+        self.nonAplicableContexts.append(context)
 
+    def addApplicableContext(self,context):
+        self.aplicableContext.append(context)
+
+    def getApplicableContext(self,context):
+        return self.applicableContext
+
+    def isApplicable(self,current):
+        returnValue = False
+        unapplicableContextsFound = 0
+        if None in self.applicableContext:
+            returnValue = True
+
+        if self.nonAplicableContexts is None:
+             returnValue = True
+
+        for context in self.nonAplicableContexts:
+            if context in self.nonAplicableContexts:
+                return False
+            if context in self.aplicableContext:
+                returnValue = True
+
+        return returnValue
+
+    def getDependencies(self):
+        return self.dependencies
+
+    def getApplicableDependencies(self, context):
+        applicableDeps = Refinement()
+        for dep in self.dependencies:
+            for cont in context:
+                if context in dep.getApplicableContext() or None in dep.getApplicableContext():
+                    applicableDeps.add(dep)
+        return applicableDeps
+
+    def  getIdentifier(self):
+        return self.identifier
 
+    def setIdentifier(self, identifier):
+        self.identifier = identifier

goald/quality/pragmatic/model/task.py

@@ -1,6 +1,7 @@
 from goald.quality.pragmatic.model.context import Context
+from goald.quality.pragmatic.model.refinement import Refinement
 
-class Task():
+class Task(Refinement):
     def __init__(self, metric, contextValueMap, lessIsMore):
         self.providedQualityLevels[metric] = contextValueMap
         self.lessIsMore = lessIsMore
@@ -9,6 +10,10 @@ def __init__(self):
         self.providedQualityLevels = {}
         self.lessIsMore = False
 
+    def myType(self):
+        refinement = Refinement()
+        return refinement.TASK
+
     def setProvidedQuality(self, context, metric, value):
         map = {}
 
@@ -43,4 +48,4 @@ def myProvidedQuality(self, metric, contextSet):
                     elif(myQuality < self.providedQualityLevels[metric][current]):
                         myQuality = self.providedQualityLevels[metric][current]
 
-        return myQuality
+        return myQuality

tests/goald_configuration/test_model.py

@@ -5,8 +5,7 @@
 from goald.config.model.dependency import Dependency
 from goald.config.model.deployment import Deployment, Status
 from goald.config.model.dependency_modifier import DependencyModifier, Type
-from goald.config.model.goal import Goal
-from goald.config.model.ve import VE
+from goald.quality.pragmatic.model.goal import Goal
 
 
 def test_alternative():

tests/quality_pragmaitc/test_interpretation.py

@@ -8,7 +8,7 @@ def test_interpretation():
     interp = Interpretation()
     context = Context("C1")
     commonMetrics = CommonMetrics()
-    qc =  QualityConstraint(context, commonMetrics.SECONDS, 15, 'LESS_THAN')
+    qc = QualityConstraint(context, commonMetrics.SECONDS, 15, 'LESS_THAN')
 
     interp.addQualityConstraint(qc)
     map = interp.getContextDependentInterpretation()

tests/quality_pragmaitc/test_quality_constraint.py

@@ -19,14 +19,17 @@ def test_should_select_stricter_constraint():
     assert moreStrictQC == moreStrictQC.stricterQC(lessStrictQC)
 
 def test_should_get_correct_threshold():
-		qc = QualityConstraint(Context("C1"), Metrics(('SECONDS', True)), 15, 'LESS_THAN')
-		print(qc.value)
-		assert 15 == qc.value
+    commonMetrics = CommonMetrics()
+    qc = QualityConstraint(Context("C1"), commonMetrics.SECONDS, 15, 'LESS_THAN')
+    print(qc.value)
+    assert 15 == qc.value
 
 def test_should_get_correct_comparison():
-		qc = QualityConstraint(Context("C1"), Metrics(('SECONDS', True)), 15, 'LESS_THAN')
-		assert  'LESS_THAN' == qc.comparison
-#find a way to fix the enum transformation
+    commonMetrics = CommonMetrics()
+    qc = QualityConstraint(Context("C1"), commonMetrics.SECONDS, 15, 'LESS_THAN')
+    assert  'LESS_THAN' == qc.comparison
+
 def should_get_correct_metric():
-        qc = QualityConstraint(Context("C1"), Metrics(('SECONDS', True)), 15, 'LESS_THAN')
-        assert 'SECONDS' == qc.metric
+    commonMetrics = CommonMetrics()
+    qc = QualityConstraint(Context("C1"), commonMetrics.SECONDS, 15, 'LESS_THAN')
+    assert CommonMetrics.SECONDS == qc.metric

tests/quality_pragmaitc/test_refinement.py

@@ -0,0 +1,8 @@
+from goald.quality.pragmatic.model.refinement import Refinement
+from goald.quality.pragmatic.model.task import Task
+
+def test_refinement():
+    task = Task()
+    refinement = Refinement()
+    assert task.myType() == refinement.TASK
+