move analyzers in separate files

Author: xchrdw

propertysuggester/analyzer/RuleGenerator.py

@@ -1,5 +1,7 @@
 from collections import defaultdict
 import itertools
+from propertysuggester.analyzer.impl.MainAnalyzer import ItemAnalyzer
+from propertysuggester.analyzer.impl.QualifierReferenceAnalyzer import QualifierAnalyzer, ReferenceAnalyzer
 from propertysuggester.analyzer.rule import Rule
 from propertysuggester.utils.datamodel import Entity
 
@@ -21,74 +23,3 @@ def compute_rules(entities, min_probability=0.01):
     rules = filter(lambda rule: rule.probability > min_probability, itertools.chain(*(a.get_rules() for a in analyzers)))
     return rules
 
-
-class Analyzer:
-    def __init__(self, context):
-        """
-        @type context: string
-        """
-        self.propertyOccurances = defaultdict(int)
-        self.coOccurances = defaultdict(lambda: defaultdict(int))
-        self.context = context
-
-    def process(self, entity):
-        """
-        @type entity: Entity
-        """
-        raise NotImplemented("Please implement this method")
-
-    def get_rules(self):
-        """
-        @return: list[Rule]
-        """
-        rules = []
-        for pid1, row in self.coOccurances.iteritems():
-            pid1count = self.propertyOccurances[pid1]
-            for pid2, value in row.iteritems():
-                if value > 0:
-                    probability = value/float(pid1count)
-                    rules.append(Rule(pid1, None, pid2, value, probability, self.context))
-        return rules
-
-
-class ItemAnalyzer(Analyzer):
-    def __init__(self):
-        Analyzer.__init__(self, "item")
-
-    def process(self, entity):
-        distinct_ids = set(claim.mainsnak.property_id for claim in entity.claims)
-        self._count_occurances(distinct_ids)
-
-    def _count_occurances(self, distinct_ids):
-        for pid1 in distinct_ids:
-            self.propertyOccurances[pid1] += 1
-            for pid2 in distinct_ids:
-                if pid1 != pid2:
-                    self.coOccurances[pid1][pid2] += 1
-
-
-class QualifierAnalyzer(Analyzer):
-    def __init__(self):
-        Analyzer.__init__(self, "qualifier")
-
-    def process(self, entity):
-        for claim in entity.claims:
-            distinct_pids = set(q.property_id for q in self.get_special(claim))
-            if len(distinct_pids) > 0:
-                self.propertyOccurances[claim.mainsnak.property_id] += 1
-                self._count_special_appearances(claim.mainsnak.property_id, distinct_pids)
-
-    def _count_special_appearances(self, mainsnak_id, distinct_ids):
-        for pid in distinct_ids:
-            self.coOccurances[mainsnak_id][pid] += 1
-
-    def get_special(self, claim):
-        return claim.qualifiers
-
-
-class ReferenceAnalyzer(QualifierAnalyzer):
-    def __init__(self):
-        Analyzer.__init__(self, "reference")
-
-    def get_special(self, claim):
-        return claim.references

propertysuggester/analyzer/impl/Analyzer.py

@@ -0,0 +1,19 @@
+from collections import defaultdict
+from propertysuggester.analyzer.rule import Rule
+from propertysuggester.utils.datamodel import Entity
+
+class Analyzer:
+    def __init__(self):
+        pass
+
+    def process(self, entity):
+        """
+        @type entity: Entity
+        """
+        raise NotImplementedError("Please implement this method")
+
+    def get_rules(self):
+        """
+        @return: list[Rule]
+        """
+        raise NotImplementedError("Please implement this method")

propertysuggester/analyzer/impl/MainAnalyzer.py

@@ -0,0 +1,31 @@
+from collections import defaultdict
+from propertysuggester.analyzer.impl.Analyzer import Analyzer
+from propertysuggester.analyzer.rule import Rule
+
+
+class ItemAnalyzer(Analyzer):
+    def __init__(self):
+        Analyzer.__init__(self)
+        self.propertyOccurances = defaultdict(int)
+        self.coOccurances = defaultdict(lambda: defaultdict(int))
+    
+    def process(self, entity):
+        distinct_ids = set(claim.mainsnak.property_id for claim in entity.claims)
+        self._count_occurances(distinct_ids)
+
+    def _count_occurances(self, distinct_ids):
+        for pid1 in distinct_ids:
+            self.propertyOccurances[pid1] += 1
+            for pid2 in distinct_ids:
+                if pid1 != pid2:
+                    self.coOccurances[pid1][pid2] += 1
+
+    def get_rules(self):
+        rules = []
+        for pid1, row in self.coOccurances.iteritems():
+            pid1count = self.propertyOccurances[pid1]
+            for pid2, paircount in row.iteritems():
+                if paircount > 0:
+                    probability = (paircount/float(pid1count))
+                    rules.append(Rule(pid1, None, pid2, paircount, probability, "item"))
+        return rules

propertysuggester/analyzer/impl/QualifierReferenceAnalyzer.py

@@ -0,0 +1,45 @@
+from collections import defaultdict
+from propertysuggester.analyzer.impl.Analyzer import Analyzer
+from propertysuggester.analyzer.rule import Rule
+
+
+class QualifierAnalyzer(Analyzer):
+    def __init__(self):
+        Analyzer.__init__(self)
+        self.mainOccurances = defaultdict(int)
+        self.qualifierOccurances = defaultdict(lambda: defaultdict(int))
+        self.context = "qualifier"
+
+    def process(self, entity):
+        for claim in entity.claims:
+            distinct_pids = set(q.property_id for q in self.get_special(claim))
+            if len(distinct_pids) > 0:
+                main_pid = claim.mainsnak.property_id
+                self.mainOccurances[main_pid] += 1
+                self._count_special_appearances(main_pid, distinct_pids)
+
+    def _count_special_appearances(self, mainsnak_id, distinct_ids):
+        for pid in distinct_ids:
+            self.qualifierOccurances[mainsnak_id][pid] += 1
+
+    def get_special(self, claim):
+        return claim.qualifiers
+
+    def get_rules(self):
+        rules = []
+        for main_pid, row in self.qualifierOccurances.iteritems():
+            maincount = self.mainOccurances[main_pid]
+            for qualifier_pid, paircount in row.iteritems():
+                if paircount > 0:
+                    probability = paircount/float(maincount)
+                    rules.append(Rule(main_pid, None, qualifier_pid, paircount, probability, self.context))
+        return rules
+
+
+class ReferenceAnalyzer(QualifierAnalyzer):
+    def __init__(self):
+        QualifierAnalyzer.__init__(self)
+        self.context = "reference"
+
+    def get_special(self, claim):
+        return claim.references

propertysuggester/analyzer/impl/__init__.py

@@ -0,0 +1 @@
+__author__ = 'Christian'