Update guessit to 3.0.0 (+subliminal update)

ext/guessit/__init__.py

@@ -5,5 +5,6 @@
 """
 from .api import guessit, GuessItApi
 from .options import ConfigurationException
+from .rules.common.quantity import Size
 
 from .__version__ import __version__

ext/guessit/__main__.py

@@ -20,6 +20,12 @@
 from guessit.options import argument_parser, parse_options, load_config
 
 
+try:
+    from collections import OrderedDict
+except ImportError:  # pragma: no-cover
+    from ordereddict import OrderedDict  # pylint:disable=import-error
+
+
 def guess_filename(filename, options):
     """
     Guess a single filename using given options
@@ -45,7 +51,7 @@ def guess_filename(filename, options):
         import yaml
         from guessit import yamlutils
 
-        ystr = yaml.dump({filename: dict(guess)}, Dumper=yamlutils.CustomDumper, default_flow_style=False,
+        ystr = yaml.dump({filename: OrderedDict(guess)}, Dumper=yamlutils.CustomDumper, default_flow_style=False,
                          allow_unicode=True)
         i = 0
         for yline in ystr.splitlines():

ext/guessit/__version__.py

@@ -4,4 +4,4 @@
 Version module
 """
 # pragma: no cover
-__version__ = '2.1.4'
+__version__ = '3.0.0'

ext/guessit/api.py

@@ -3,19 +3,21 @@
 """
 API functions that can be used by external software
 """
+
 try:
     from collections import OrderedDict
 except ImportError:  # pragma: no-cover
     from ordereddict import OrderedDict  # pylint:disable=import-error
 
+import os
 import traceback
 
 import six
 
 from rebulk.introspector import introspect
 
 from .rules import rebulk_builder
-from .options import parse_options
+from .options import parse_options, load_config
 from .__version__ import __version__
 
 
@@ -41,12 +43,25 @@ def __init__(self, string, options):
         self.options = options
 
 
+def configure(options, rules_builder=rebulk_builder):
+    """
+    Load rebulk rules according to advanced configuration in options dictionary.
+
+    :param options:
+    :type options: dict
+    :param rules_builder:
+    :type rules_builder:
+    :return:
+    """
+    default_api.configure(options, rules_builder=rules_builder, force=True)
+
+
 def guessit(string, options=None):
     """
     Retrieves all matches from string as a dict
     :param string: the filename or release name
     :type string: str
-    :param options: the filename or release name
+    :param options:
     :type options: str|dict
     :return:
     :rtype:
@@ -58,7 +73,7 @@ def properties(options=None):
     """
     Retrieves all properties with possible values that can be guessed
     :param options:
-    :type options:
+    :type options: str|dict
     :return:
     :rtype:
     """
@@ -70,53 +85,88 @@ class GuessItApi(object):
     An api class that can be configured with custom Rebulk configuration.
     """
 
-    def __init__(self, rebulk):
-        """
-        :param rebulk: Rebulk instance to use.
-        :type rebulk: Rebulk
-        :return:
-        :rtype:
-        """
-        self.rebulk = rebulk
+    def __init__(self):
+        """Default constructor."""
+        self.rebulk = None
 
-    @staticmethod
-    def _fix_option_encoding(value):
+    @classmethod
+    def _fix_encoding(cls, value):
         if isinstance(value, list):
-            return [GuessItApi._fix_option_encoding(item) for item in value]
+            return [cls._fix_encoding(item) for item in value]
+        if isinstance(value, dict):
+            return {cls._fix_encoding(k): cls._fix_encoding(v) for k, v in value.items()}
         if six.PY2 and isinstance(value, six.text_type):
-            return value.encode("utf-8")
+            return value.encode('utf-8')
         if six.PY3 and isinstance(value, six.binary_type):
             return value.decode('ascii')
         return value
 
-    def guessit(self, string, options=None):
+    def configure(self, options, rules_builder=rebulk_builder, force=False):
+        """
+        Load rebulk rules according to advanced configuration in options dictionary.
+
+        :param options:
+        :type options: str|dict
+        :param rules_builder:
+        :type rules_builder:
+        :param force:
+        :return:
+        :rtype: dict
+        """
+        options = parse_options(options, True)
+        should_load = force or not self.rebulk
+        advanced_config = options.pop('advanced_config', None)
+
+        if should_load and not advanced_config:
+            advanced_config = load_config(options)['advanced_config']
+
+        options = self._fix_encoding(options)
+
+        if should_load:
+            advanced_config = self._fix_encoding(advanced_config)
+            self.rebulk = rules_builder(advanced_config)
+
+        return options
+
+    def guessit(self, string, options=None):  # pylint: disable=too-many-branches
         """
         Retrieves all matches from string as a dict
         :param string: the filename or release name
-        :type string: str
-        :param options: the filename or release name
+        :type string: str|Path
+        :param options:
         :type options: str|dict
         :return:
         :rtype:
         """
         try:
-            options = parse_options(options, True)
+            from pathlib import Path
+            if isinstance(string, Path):
+                try:
+                    # Handle path-like object
+                    string = os.fspath(string)
+                except AttributeError:
+                    string = str(string)
+        except ImportError:
+            pass
+
+        try:
+            options = self.configure(options)
             result_decode = False
             result_encode = False
 
-            fixed_options = {}
-            for (key, value) in options.items():
-                key = GuessItApi._fix_option_encoding(key)
-                value = GuessItApi._fix_option_encoding(value)
-                fixed_options[key] = value
-            options = fixed_options
-
-            if six.PY2 and isinstance(string, six.text_type):
-                string = string.encode("utf-8")
-                result_decode = True
-            if six.PY3 and isinstance(string, six.binary_type):
-                string = string.decode('ascii')
-                result_encode = True
+            if six.PY2:
+                if isinstance(string, six.text_type):
+                    string = string.encode("utf-8")
+                    result_decode = True
+                elif isinstance(string, six.binary_type):
+                    string = six.binary_type(string)
+            if six.PY3:
+                if isinstance(string, six.binary_type):
+                    string = string.decode('ascii')
+                    result_encode = True
+                elif isinstance(string, six.text_type):
+                    string = six.text_type(string)
+
             matches = self.rebulk.matches(string, options)
             if result_decode:
                 for match in matches:
@@ -139,6 +189,7 @@ def properties(self, options=None):
         :return:
         :rtype:
         """
+        options = self.configure(options)
         unordered = introspect(self.rebulk, options).properties
         ordered = OrderedDict()
         for k in sorted(unordered.keys(), key=six.text_type):
@@ -148,4 +199,4 @@ def properties(self, options=None):
         return ordered
 
 
-default_api = GuessItApi(rebulk_builder())
+default_api = GuessItApi()