Update libs

libs/guessit/guess.py

@@ -41,15 +41,21 @@ class Guess(UnicodeMixin, dict):
             confidence = kwargs.pop('confidence')
         except KeyError:
             confidence = 0
+            
+        try:
+            raw = kwargs.pop('raw')
+        except KeyError:
+            raw = None
 
         dict.__init__(self, *args, **kwargs)
 
         self._confidence = {}
+        self._raw = {}
         for prop in self:
             self._confidence[prop] = confidence
-
-
-    def to_dict(self):
+            self._raw[prop] = raw
+            
+    def to_dict(self, advanced=False):
         data = dict(self)
         for prop, value in data.items():
             if isinstance(value, datetime.date):
@@ -58,46 +64,65 @@ class Guess(UnicodeMixin, dict):
                 data[prop] = u(value)
             elif isinstance(value, list):
                 data[prop] = [u(x) for x in value]
+            if advanced:
+                data[prop] = {"value": data[prop], "raw": self.raw(prop), "confidence": self.confidence(prop)}
 
         return data
 
-    def nice_string(self):
-        data = self.to_dict()
-
-        parts = json.dumps(data, indent=4).split('\n')
-        for i, p in enumerate(parts):
-            if p[:5] != '    "':
-                continue
-
-            prop = p.split('"')[1]
-            parts[i] = ('    [%.2f] "' % self.confidence(prop)) + p[5:]
-
-        return '\n'.join(parts)
+    def nice_string(self, advanced=False):
+        if advanced:
+            data = self.to_dict(advanced)
+            return json.dumps(data, indent=4)
+        else:            
+            data = self.to_dict()
+    
+            parts = json.dumps(data, indent=4).split('\n')
+            for i, p in enumerate(parts):
+                if p[:5] != '    "':
+                    continue
+    
+                prop = p.split('"')[1]
+                parts[i] = ('    [%.2f] "' % self.confidence(prop)) + p[5:]
+    
+            return '\n'.join(parts)
 
     def __unicode__(self):
         return u(self.to_dict())
 
     def confidence(self, prop):
         return self._confidence.get(prop, -1)
+    
+    def raw(self, prop):
+        return self._raw.get(prop, None)
 
-    def set(self, prop, value, confidence=None):
+    def set(self, prop, value, confidence=None, raw=None):
         self[prop] = value
         if confidence is not None:
             self._confidence[prop] = confidence
+        if raw is not None:
+            self._raw[prop] = raw
 
     def set_confidence(self, prop, value):
         self._confidence[prop] = value
+        
+    def set_raw(self, prop, value):
+        self._raw[prop] = value
 
-    def update(self, other, confidence=None):
+    def update(self, other, confidence=None, raw=None):
         dict.update(self, other)
         if isinstance(other, Guess):
             for prop in other:
                 self._confidence[prop] = other.confidence(prop)
+                self._raw[prop] = other.raw(prop)
 
         if confidence is not None:
             for prop in other:
                 self._confidence[prop] = confidence
 
+        if raw is not None:
+            for prop in other:
+                self._raw[prop] = raw
+
     def update_highest_confidence(self, other):
         """Update this guess with the values from the given one. In case
         there is property present in both, only the one with the highest one
@@ -110,6 +135,7 @@ class Guess(UnicodeMixin, dict):
                 continue
             self[prop] = other[prop]
             self._confidence[prop] = other.confidence(prop)
+            self._raw[prop] = other.raw(prop)
 
 
 def choose_int(g1, g2):
@@ -181,7 +207,7 @@ def choose_string(g1, g2):
     elif v1l in v2l:
         return (v1, combined_prob)
 
-    # in case of conflict, return the one with highest priority
+    # in case of conflict, return the one with highest confidence
     else:
         if c1 > c2:
             return (v1, c1 - c2)
@@ -288,7 +314,8 @@ def merge_all(guesses, append=None):
                 result.set(prop, result.get(prop, []) + [g[prop]],
                            # TODO: what to do with confidence here? maybe an
                            # arithmetic mean...
-                           confidence=g.confidence(prop))
+                           confidence=g.confidence(prop),
+                           raw=g.raw(prop))
 
                 del g[prop]