Merge branch 'master' of github.com:Wikidata-lib/PropertySuggester-Python into use_idf_to_rank_common_properties_lower

Conflicts:
	propertysuggester/analyzer/impl/MainAnalyzer.py

Author: xchrdw

propertysuggester/analyzer/impl/MainAnalyzer.py

@@ -7,29 +7,29 @@
 class ItemAnalyzer(Analyzer):
     def __init__(self):
         Analyzer.__init__(self)
-        self.propertyOccurances = defaultdict(int)
-        self.coOccurances = defaultdict(lambda: defaultdict(int))
+        self.property_occurances = defaultdict(int)
+        self.pair_occurances = 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
+            self.property_occurances[pid1] += 1
             for pid2 in distinct_ids:
                 if pid1 != pid2:
-                    self.coOccurances[pid1][pid2] += 1
+                    self.pair_occurances[pid1][pid2] += 1
 
     def get_rules(self):
         rules = []
-        totalpropertycount = len(self.propertyOccurances)
-        for pid1, row in self.coOccurances.iteritems():
+        totalpropertycount = len(self.property_occurances)
+        for pid1, row in self.pair_occurances.iteritems():
             sharedpids = len(row)
             idf = math.log(totalpropertycount/float(sharedpids))
-            pid1count = self.propertyOccurances[pid1]
+            pid1count = self.property_occurances[pid1]
             for pid2, paircount in row.iteritems():
                 if paircount > 0:
                     probability = (paircount/float(pid1count)) * idf
                     rules.append(Rule(pid1, None, pid2, paircount, probability, "item"))
-        return rules
+        return rules

propertysuggester/analyzer/impl/QualifierReferenceAnalyzer.py

@@ -6,29 +6,29 @@
 class QualifierAnalyzer(Analyzer):
     def __init__(self):
         Analyzer.__init__(self)
-        self.mainOccurances = defaultdict(int)
-        self.qualifierOccurances = defaultdict(lambda: defaultdict(int))
+        self.main_occurances = defaultdict(int)
+        self.qualifier_occurances = 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.main_occurances[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
+            self.qualifier_occurances[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 main_pid, row in self.qualifier_occurances.iteritems():
+            maincount = self.main_occurances[main_pid]
             for qualifier_pid, paircount in row.iteritems():
                 if paircount > 0:
                     probability = paircount/float(maincount)

propertysuggester/parser/XmlReader.py

@@ -114,7 +114,10 @@ def _parse_json_snak(claim_json):
         if datatype == "string":
             value = claim_json[3]
         elif datatype == "wikibase-entityid":
-            value = "Q" + str(claim_json[3]["numeric-id"])
+            if claim_json[3]["entity-type"] == "item":
+                value = "Q" + str(claim_json[3]["numeric-id"])
+            else:
+                print "WARNING unknown entitytype: {0}".format(claim_json[3]["entity-type"])
         elif datatype == "time":
             value = claim_json[3]["time"]
         elif datatype == "quantity":