add recommender to repository

src/managers/recommendation_manager.py

@@ -0,0 +1,89 @@
+from daos.config_dao import ConfigurationDAO
+from daos.product_structure_dao import ProductStructureDAO
+from model.configuration_model import ConfigurationModel
+from model.preferences_model import Preferences
+from model.product_structure_model import ProductStructureModel
+from scoring.scoring_functions import ReduceScoringFunctionFactory, ScoringFunction
+import numpy as np
+import operator
+
+class RecommendationManager:
+    def getRecommendation(self, preferences: Preferences , current_config : ConfigurationModel,
+        scoring_methods = "avg",
+        penalty_function = "penalty_ratio",
+        product_structure = ProductStructureDAO.getInstance().get_as_objects(),
+        configurations = ConfigurationDAO.getInstance().getAll()):
+        avg = ReduceScoringFunctionFactory.build_scoring_function(
+            [penalty_function, "pref_average_simpleSelectedCharacterstics_average"],
+            product_structure,
+            oper = operator.mul
+        )
+        lm = ReduceScoringFunctionFactory.build_scoring_function(
+            [penalty_function, "pref_min_simpleSelectedCharacterstics_average"],
+            product_structure,
+            oper = operator.mul
+        )
+        multi = ReduceScoringFunctionFactory.build_scoring_function(
+            [penalty_function, "pref_product_simpleSelectedCharacterstics_average"],
+            product_structure,
+            oper = operator.mul
+        )
+
+        default = SimpleConfigurationMaxSelector( avg )
+        switcher = {
+            "avg" : default,
+            "multi": SimpleConfigurationMaxSelector(multi),
+            "lm": SimpleConfigurationMaxSelector( lm ),
+            "avg-lm": PipeFilterMax(ConfigurationFilter(avg), SimpleConfigurationMaxSelector( lm )),
+            "lm-avg": PipeFilterMax(ConfigurationFilter(lm), SimpleConfigurationMaxSelector( avg ))
+        }
+        max_selector = switcher.get(scoring_methods, default)
+
+        return max_selector.getMax(preferences, current_config, configurations)
+
+
+class ConfigurationMaxSelector:
+    def getMax(self, preferences: Preferences, current_config : ConfigurationModel, configurations):
+        pass
+
+class PipeFilterMax(ConfigurationMaxSelector):
+    def __init__(self, configuration_filter : 'ConfigurationFilter', max_selector : ConfigurationMaxSelector):
+        self.configuration_filter = configuration_filter
+        self.max_selector = max_selector
+
+    def getMax(self, preferences: Preferences, current_config : ConfigurationModel, configurations):
+        list = self.configuration_filter.filter(preferences, current_config, configurations)
+        return self.max_selector.getMax(preferences, current_config, list)
+        
+
+class ConfigurationFilter:
+    def __init__(self, scoring_function : ScoringFunction, percentile = 50):
+        assert percentile <= 100
+        assert percentile >= 0
+        self.scoring_function = scoring_function
+        self.percentile = percentile
+    def filter(self, 
+        preferences: Preferences, 
+        current_config : ConfigurationModel, 
+        configurations):
+        
+        scores = list(map(lambda x: self.scoring_function.calc_score(current_config, preferences, ConfigurationModel(x)), configurations))
+        
+        barrier = np.percentile(np.array(scores), self.percentile)
+        return list(filter(lambda x: self.scoring_function.calc_score(current_config, preferences, ConfigurationModel(x)) > barrier, configurations))
+        
+class SimpleConfigurationMaxSelector(ConfigurationMaxSelector):
+    def __init__(self, scoring_function : ScoringFunction):
+        self.scoring_function = scoring_function
+    def getMax(self, preferences: Preferences, current_config : ConfigurationModel, configurations):
+        best_rating = float("-inf")
+        best = None
+
+        for to_rate in configurations:
+            score = self.scoring_function.calc_score(current_config, preferences, ConfigurationModel(to_rate))
+            if score > best_rating:
+                best = to_rate
+                best_rating = score
+        print('Best rating: {}'.format(best_rating))
+        return best
+