Subliminal update

libs/guessit/transfo/__init__.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit import Guess
+from guessit.patterns import canonical_form
+from guessit.textutils import clean_string
+import logging
+
+log = logging.getLogger('guessit.transfo')
+
+
+def found_property(node, name, confidence):
+    node.guess = Guess({name: node.clean_value}, confidence=confidence)
+    log.debug('Found with confidence %.2f: %s' % (confidence, node.guess))
+
+
+def format_guess(guess):
+    """Format all the found values to their natural type.
+    For instance, a year would be stored as an int value, etc...
+
+    Note that this modifies the dictionary given as input.
+    """
+    for prop, value in guess.items():
+        if prop in ('season', 'episodeNumber', 'year', 'cdNumber',
+                    'cdNumberTotal', 'bonusNumber', 'filmNumber'):
+            guess[prop] = int(guess[prop])
+        elif isinstance(value, basestring):
+            if prop in ('edition',):
+                value = clean_string(value)
+            guess[prop] = canonical_form(value)
+
+    return guess
+
+
+def find_and_split_node(node, strategy, logger):
+    string = ' %s ' % node.value # add sentinels
+    for matcher, confidence in strategy:
+        if getattr(matcher, 'use_node', False):
+            result, span = matcher(string, node)
+        else:
+            result, span = matcher(string)
+
+        if result:
+            # readjust span to compensate for sentinels
+            span = (span[0] - 1, span[1] - 1)
+
+            if isinstance(result, Guess):
+                if confidence is None:
+                    confidence = result.confidence(result.keys()[0])
+            else:
+                if confidence is None:
+                    confidence = 1.0
+
+            guess = format_guess(Guess(result, confidence=confidence))
+            msg = 'Found with confidence %.2f: %s' % (confidence, guess)
+            (logger or log).debug(msg)
+
+            node.partition(span)
+            absolute_span = (span[0] + node.offset, span[1] + node.offset)
+            for child in node.children:
+                if child.span == absolute_span:
+                    child.guess = guess
+                else:
+                    find_and_split_node(child, strategy, logger)
+            return
+
+
+class SingleNodeGuesser(object):
+    def __init__(self, guess_func, confidence, logger=None):
+        self.guess_func = guess_func
+        self.confidence = confidence
+        self.logger = logger
+
+    def process(self, mtree):
+        # strategy is a list of pairs (guesser, confidence)
+        # - if the guesser returns a guessit.Guess and confidence is specified,
+        #   it will override it, otherwise it will leave the guess confidence
+        # - if the guesser returns a simple dict as a guess and confidence is
+        #   specified, it will use it, or 1.0 otherwise
+        strategy = [ (self.guess_func, self.confidence) ]
+
+        for node in mtree.unidentified_leaves():
+            find_and_split_node(node, strategy, self.logger)

libs/guessit/transfo/guess_bonus_features.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit.transfo import found_property
+import logging
+
+log = logging.getLogger("guessit.transfo.guess_bonus_features")
+
+
+def process(mtree):
+    def previous_group(g):
+        for leaf in mtree.unidentified_leaves()[::-1]:
+            if leaf.node_idx < g.node_idx:
+                return leaf
+
+    def next_group(g):
+        for leaf in mtree.unidentified_leaves():
+            if leaf.node_idx > g.node_idx:
+                return leaf
+
+    def same_group(g1, g2):
+        return g1.node_idx[:2] == g2.node_idx[:2]
+
+    bonus = [ node for node in mtree.leaves() if 'bonusNumber' in node.guess ]
+    if bonus:
+        bonusTitle = next_group(bonus[0])
+        if same_group(bonusTitle, bonus[0]):
+            found_property(bonusTitle, 'bonusTitle', 0.8)
+
+    filmNumber = [ node for node in mtree.leaves()
+                   if 'filmNumber' in node.guess ]
+    if filmNumber:
+        filmSeries = previous_group(filmNumber[0])
+        found_property(filmSeries, 'filmSeries', 0.9)
+
+        title = next_group(filmNumber[0])
+        found_property(title, 'title', 0.9)
+
+    season = [ node for node in mtree.leaves() if 'season' in node.guess ]
+    if season and 'bonusNumber' in mtree.info:
+        series = previous_group(season[0])
+        if same_group(series, season[0]):
+            found_property(series, 'series', 0.9)

libs/guessit/transfo/guess_date.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit.transfo import SingleNodeGuesser
+from guessit.date import search_date
+import logging
+
+log = logging.getLogger("guessit.transfo.guess_date")
+
+
+def guess_date(string):
+    date, span = search_date(string)
+    if date:
+        return { 'date': date }, span
+    else:
+        return None, None
+
+
+def process(mtree):
+    SingleNodeGuesser(guess_date, 1.0, log).process(mtree)

libs/guessit/transfo/guess_episode_info_from_position.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit.transfo import found_property
+from guessit.patterns import non_episode_title, unlikely_series
+import logging
+
+log = logging.getLogger("guessit.transfo.guess_episode_info_from_position")
+
+
+def match_from_epnum_position(mtree, node):
+    epnum_idx = node.node_idx
+
+    # a few helper functions to be able to filter using high-level semantics
+    def before_epnum_in_same_pathgroup():
+        return [ leaf for leaf in mtree.unidentified_leaves()
+                 if (leaf.node_idx[0] == epnum_idx[0] and
+                     leaf.node_idx[1:] < epnum_idx[1:]) ]
+
+    def after_epnum_in_same_pathgroup():
+        return [ leaf for leaf in mtree.unidentified_leaves()
+                 if (leaf.node_idx[0] == epnum_idx[0] and
+                     leaf.node_idx[1:] > epnum_idx[1:]) ]
+
+    def after_epnum_in_same_explicitgroup():
+        return [ leaf for leaf in mtree.unidentified_leaves()
+                 if (leaf.node_idx[:2] == epnum_idx[:2] and
+                     leaf.node_idx[2:] > epnum_idx[2:]) ]
+
+    # epnumber is the first group and there are only 2 after it in same
+    # path group
+    # -> series title - episode title
+    title_candidates = [ n for n in after_epnum_in_same_pathgroup()
+                         if n.clean_value.lower() not in non_episode_title ]
+    if ('title' not in mtree.info and                # no title
+        before_epnum_in_same_pathgroup() == [] and   # no groups before
+        len(title_candidates) == 2):                 # only 2 groups after
+
+        found_property(title_candidates[0], 'series', confidence=0.4)
+        found_property(title_candidates[1], 'title', confidence=0.4)
+        return
+
+    # if we have at least 1 valid group before the episodeNumber, then it's
+    # probably the series name
+    series_candidates = before_epnum_in_same_pathgroup()
+    if len(series_candidates) >= 1:
+        found_property(series_candidates[0], 'series', confidence=0.7)
+
+    # only 1 group after (in the same path group) and it's probably the
+    # episode title
+    title_candidates = [ n for n in after_epnum_in_same_pathgroup()
+                         if n.clean_value.lower() not in non_episode_title ]
+
+    if len(title_candidates) == 1:
+        found_property(title_candidates[0], 'title', confidence=0.5)
+        return
+    else:
+        # try in the same explicit group, with lower confidence
+        title_candidates = [ n for n in after_epnum_in_same_explicitgroup()
+                             if n.clean_value.lower() not in non_episode_title
+                             ]
+        if len(title_candidates) == 1:
+            found_property(title_candidates[0], 'title', confidence=0.4)
+            return
+        elif len(title_candidates) > 1:
+            found_property(title_candidates[0], 'title', confidence=0.3)
+            return
+
+    # get the one with the longest value
+    title_candidates = [ n for n in after_epnum_in_same_pathgroup()
+                         if n.clean_value.lower() not in non_episode_title ]
+    if title_candidates:
+        maxidx = -1
+        maxv = -1
+        for i, c in enumerate(title_candidates):
+            if len(c.clean_value) > maxv:
+                maxidx = i
+                maxv = len(c.clean_value)
+        found_property(title_candidates[maxidx], 'title', confidence=0.3)
+
+
+def process(mtree):
+    eps = [node for node in mtree.leaves() if 'episodeNumber' in node.guess]
+    if eps:
+        match_from_epnum_position(mtree, eps[0])
+
+    else:
+        # if we don't have the episode number, but at least 2 groups in the
+        # basename, then it's probably series - eptitle
+        basename = mtree.node_at((-2,))
+        title_candidates = [ n for n in basename.unidentified_leaves()
+                             if n.clean_value.lower() not in non_episode_title
+                             ]
+
+        if len(title_candidates) >= 2:
+            found_property(title_candidates[0], 'series', 0.4)
+            found_property(title_candidates[1], 'title', 0.4)
+
+    # if we only have 1 remaining valid group in the folder containing the
+    # file, then it's likely that it is the series name
+    try:
+        series_candidates = mtree.node_at((-3,)).unidentified_leaves()
+    except ValueError:
+        series_candidates = []
+
+    if len(series_candidates) == 1:
+        found_property(series_candidates[0], 'series', 0.3)
+
+    # if there's a path group that only contains the season info, then the
+    # previous one is most likely the series title (ie: ../series/season X/..)
+    eps = [ node for node in mtree.nodes()
+            if 'season' in node.guess and 'episodeNumber' not in node.guess ]
+
+    if eps:
+        previous = [ node for node in mtree.unidentified_leaves()
+                     if node.node_idx[0] == eps[0].node_idx[0] - 1 ]
+        if len(previous) == 1:
+            found_property(previous[0], 'series', 0.5)
+
+    # reduce the confidence of unlikely series
+    for node in mtree.nodes():
+        if 'series' in node.guess:
+            if node.guess['series'].lower() in unlikely_series:
+                new_confidence = node.guess.confidence('series') * 0.5
+                node.guess.set_confidence('series', new_confidence)

libs/guessit/transfo/guess_episodes_rexps.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit import Guess
+from guessit.transfo import SingleNodeGuesser
+from guessit.patterns import episode_rexps
+import re
+import logging
+
+log = logging.getLogger("guessit.transfo.guess_episodes_rexps")
+
+
+def guess_episodes_rexps(string):
+    for rexp, confidence, span_adjust in episode_rexps:
+        match = re.search(rexp, string, re.IGNORECASE)
+        if match:
+            return (Guess(match.groupdict(), confidence=confidence),
+                    (match.start() + span_adjust[0],
+                     match.end() + span_adjust[1]))
+
+    return None, None
+
+
+def process(mtree):
+    SingleNodeGuesser(guess_episodes_rexps, None, log).process(mtree)

libs/guessit/transfo/guess_filetype.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit import Guess
+from guessit.patterns import (subtitle_exts, video_exts, episode_rexps,
+                              find_properties, canonical_form)
+import os.path
+import re
+import mimetypes
+import logging
+
+log = logging.getLogger("guessit.transfo.guess_filetype")
+
+
+def guess_filetype(filename, filetype):
+    other = {}
+
+    # look at the extension first
+    fileext = os.path.splitext(filename)[1][1:].lower()
+    if fileext in subtitle_exts:
+        if 'movie' in filetype:
+            filetype = 'moviesubtitle'
+        elif 'episode' in filetype:
+            filetype = 'episodesubtitle'
+        else:
+            filetype = 'subtitle'
+        other = { 'container': fileext }
+    elif fileext in video_exts:
+        if filetype == 'autodetect':
+            filetype = 'video'
+        other = { 'container': fileext }
+    else:
+        if filetype == 'autodetect':
+            filetype = 'unknown'
+        other = { 'extension': fileext }
+
+    # put the filetype inside a dummy container to be able to have the
+    # following functions work correctly as closures
+    # this is a workaround for python 2 which doesn't have the
+    # 'nonlocal' keyword (python 3 does have it)
+    filetype_container = [filetype]
+
+    def upgrade_episode():
+        if filetype_container[0] == 'video':
+            filetype_container[0] = 'episode'
+        elif filetype_container[0] == 'subtitle':
+            filetype_container[0] = 'episodesubtitle'
+
+    def upgrade_movie():
+        if filetype_container[0] == 'video':
+            filetype_container[0] = 'movie'
+        elif filetype_container[0] == 'subtitle':
+            filetype_container[0] = 'moviesubtitle'
+
+    # now look whether there are some specific hints for episode vs movie
+    if filetype in ('video', 'subtitle'):
+        for rexp, _, _ in episode_rexps:
+            match = re.search(rexp, filename, re.IGNORECASE)
+            if match:
+                upgrade_episode()
+                break
+
+        for prop, value, _, _ in find_properties(filename):
+            log.debug('prop: %s = %s' % (prop, value))
+            if prop == 'episodeFormat':
+                upgrade_episode()
+                break
+
+            elif canonical_form(value) == 'DVB':
+                upgrade_episode()
+                break
+
+        # if no episode info found, assume it's a movie
+        upgrade_movie()
+
+    filetype = filetype_container[0]
+    return filetype, other
+
+
+def process(mtree, filetype='autodetect'):
+    filetype, other = guess_filetype(mtree.string, filetype)
+
+    mtree.guess.set('type', filetype, confidence=1.0)
+    log.debug('Found with confidence %.2f: %s' % (1.0, mtree.guess))
+
+    filetype_info = Guess(other, confidence=1.0)
+    # guess the mimetype of the filename
+    # TODO: handle other mimetypes not found on the default type_maps
+    # mimetypes.types_map['.srt']='text/subtitle'
+    mime, _ = mimetypes.guess_type(mtree.string, strict=False)
+    if mime is not None:
+        filetype_info.update({'mimetype': mime}, confidence=1.0)
+
+    node_ext = mtree.node_at((-1,))
+    node_ext.guess = filetype_info
+    log.debug('Found with confidence %.2f: %s' % (1.0, node_ext.guess))

libs/guessit/transfo/guess_language.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit import Guess
+from guessit.transfo import SingleNodeGuesser
+from guessit.language import search_language
+from guessit.textutils import clean_string
+import logging
+
+log = logging.getLogger("guessit.transfo.guess_language")
+
+
+def guess_language(string):
+    language, span, confidence = search_language(string)
+    if language:
+        # is it a subtitle language?
+        if 'sub' in clean_string(string[:span[0]]).lower().split(' '):
+            return (Guess({'subtitleLanguage': language},
+                          confidence=confidence),
+                    span)
+        else:
+            return (Guess({'language': language},
+                          confidence=confidence),
+                    span)
+
+    return None, None
+
+
+def process(mtree):
+    SingleNodeGuesser(guess_language, None, log).process(mtree)

libs/guessit/transfo/guess_movie_title_from_position.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit import Guess
+import logging
+
+log = logging.getLogger("guessit.transfo.guess_movie_title_from_position")
+
+
+def process(mtree):
+    def found_property(node, name, value, confidence):
+        node.guess = Guess({ name: value },
+                           confidence=confidence)
+        log.debug('Found with confidence %.2f: %s' % (confidence, node.guess))
+
+    def found_title(node, confidence):
+        found_property(node, 'title', node.clean_value, confidence)
+
+    basename = mtree.node_at((-2,))
+    all_valid = lambda leaf: len(leaf.clean_value) > 0
+    basename_leftover = basename.unidentified_leaves(valid=all_valid)
+
+    try:
+        folder = mtree.node_at((-3,))
+        folder_leftover = folder.unidentified_leaves()
+    except ValueError:
+        folder = None
+        folder_leftover = []
+
+    log.debug('folder: %s' % folder_leftover)
+    log.debug('basename: %s' % basename_leftover)
+
+    # specific cases:
+    # if we find the same group both in the folder name and the filename,
+    # it's a good candidate for title
+    if (folder_leftover and basename_leftover and
+        folder_leftover[0].clean_value == basename_leftover[0].clean_value):
+
+        found_title(folder_leftover[0], confidence=0.8)
+        return
+
+    # specific cases:
+    # if the basename contains a number first followed by an unidentified
+    # group, and the folder only contains 1 unidentified one, then we have
+    # a series
+    # ex: Millenium Trilogy (2009)/(1)The Girl With The Dragon Tattoo(2009).mkv
+    try:
+        series = folder_leftover[0]
+        filmNumber = basename_leftover[0]
+        title = basename_leftover[1]
+
+        basename_leaves = basename.leaves()
+
+        num = int(filmNumber.clean_value)
+
+        log.debug('series: %s' % series.clean_value)
+        log.debug('title: %s' % title.clean_value)
+        if (series.clean_value != title.clean_value and
+            series.clean_value != filmNumber.clean_value and
+            basename_leaves.index(filmNumber) == 0 and
+            basename_leaves.index(title) == 1):
+
+            found_title(title, confidence=0.6)
+            found_property(series, 'filmSeries',
+                           series.clean_value, confidence=0.6)
+            found_property(filmNumber, 'filmNumber',
+                           num, confidence=0.6)
+        return
+    except Exception:
+        pass
+
+    # specific cases:
+    #  - movies/tttttt (yyyy)/tttttt.ccc
+    try:
+        if mtree.node_at((-4, 0)).value.lower() == 'movies':
+            folder = mtree.node_at((-3,))
+
+            # Note:too generic, might solve all the unittests as they all
+            # contain 'movies' in their path
+            #
+            #if containing_folder.is_leaf() and not containing_folder.guess:
+            #    containing_folder.guess =
+            #        Guess({ 'title': clean_string(containing_folder.value) },
+            #              confidence=0.7)
+
+            year_group = folder.first_leaf_containing('year')
+            groups_before = folder.previous_unidentified_leaves(year_group)
+
+            found_title(groups_before[0], confidence=0.8)
+            return
+
+    except Exception:
+        pass
+
+    # if we have either format or videoCodec in the folder containing the file
+    # or one of its parents, then we should probably look for the title in
+    # there rather than in the basename
+    try:
+        props = mtree.previous_leaves_containing(mtree.children[-2],
+                                                 [ 'videoCodec', 'format',
+                                                   'language' ])
+    except IndexError:
+        props = []
+
+    if props:
+        group_idx = props[0].node_idx[0]
+        if all(g.node_idx[0] == group_idx for g in props):
+            # if they're all in the same group, take leftover info from there
+            leftover = mtree.node_at((group_idx,)).unidentified_leaves()
+
+            if leftover:
+                found_title(leftover[0], confidence=0.7)
+                return
+
+    # look for title in basename if there are some remaining undidentified
+    # groups there
+    if basename_leftover:
+        title_candidate = basename_leftover[0]
+
+        # if basename is only one word and the containing folder has at least
+        # 3 words in it, we should take the title from the folder name
+        # ex: Movies/Alice in Wonderland DVDRip.XviD-DiAMOND/dmd-aw.avi
+        # ex: Movies/Somewhere.2010.DVDRip.XviD-iLG/i-smwhr.avi  <-- TODO: gets caught here?
+        if (title_candidate.clean_value.count(' ') == 0 and
+            folder_leftover and
+            folder_leftover[0].clean_value.count(' ') >= 2):
+
+            found_title(folder_leftover[0], confidence=0.7)
+            return
+
+        # if there are only 2 unidentified groups, the first of which is inside
+        # brackets or parentheses, we take the second one for the title:
+        # ex: Movies/[阿维达].Avida.2006.FRENCH.DVDRiP.XViD-PROD.avi
+        if len(basename_leftover) == 2 and basename_leftover[0].is_explicit():
+            found_title(basename_leftover[1], confidence=0.8)
+            return
+
+        # if all else fails, take the first remaining unidentified group in the
+        # basename as title
+        found_title(title_candidate, confidence=0.6)
+        return
+
+    # if there are no leftover groups in the basename, look in the folder name
+    if folder_leftover:
+        found_title(folder_leftover[0], confidence=0.5)
+        return
+
+    # if nothing worked, look if we have a very small group at the beginning
+    # of the basename
+    basename = mtree.node_at((-2,))
+    basename_leftover = basename.unidentified_leaves(valid=lambda leaf: True)
+    if basename_leftover:
+        found_title(basename_leftover[0], confidence=0.4)
+        return

libs/guessit/transfo/guess_properties.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit.transfo import SingleNodeGuesser
+from guessit.patterns import find_properties
+import logging
+
+log = logging.getLogger("guessit.transfo.guess_properties")
+
+
+def guess_properties(string):
+    try:
+        prop, value, pos, end = find_properties(string)[0]
+        return { prop: value }, (pos, end)
+    except IndexError:
+        return None, None
+
+
+def process(mtree):
+    SingleNodeGuesser(guess_properties, 1.0, log).process(mtree)

libs/guessit/transfo/guess_release_group.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit.transfo import SingleNodeGuesser
+import re
+import logging
+
+log = logging.getLogger("guessit.transfo.guess_release_group")
+
+
+def guess_release_group(string):
+    group_names = [ r'\.(Xvid)-(?P<releaseGroup>.*?)[ \.]',
+                    r'\.(DivX)-(?P<releaseGroup>.*?)[\. ]',
+                    r'\.(DVDivX)-(?P<releaseGroup>.*?)[\. ]',
+                    ]
+    for rexp in group_names:
+        match = re.search(rexp, string, re.IGNORECASE)
+        if match:
+            metadata = match.groupdict()
+            metadata.update({ 'videoCodec': match.group(1) })
+            return metadata, (match.start() + 1, match.end() - 1)
+
+    return None, None
+
+
+def process(mtree):
+    SingleNodeGuesser(guess_release_group, 0.8, log).process(mtree)

libs/guessit/transfo/guess_video_rexps.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit import Guess
+from guessit.transfo import SingleNodeGuesser
+from guessit.patterns import video_rexps, sep
+import re
+import logging
+
+log = logging.getLogger("guessit.transfo.guess_video_rexps")
+
+
+def guess_video_rexps(string):
+    string = '-' + string + '-'
+    for rexp, confidence, span_adjust in video_rexps:
+        match = re.search(sep + rexp + sep, string, re.IGNORECASE)
+        if match:
+            metadata = match.groupdict()
+            # is this the better place to put it? (maybe, as it is at least
+            # the soonest that we can catch it)
+            if metadata.get('cdNumberTotal', -1) is None:
+                del metadata['cdNumberTotal']
+            return (Guess(metadata, confidence=confidence),
+                    (match.start() + span_adjust[0],
+                     match.end() + span_adjust[1] - 2))
+
+    return None, None
+
+
+def process(mtree):
+    SingleNodeGuesser(guess_video_rexps, None, log).process(mtree)

libs/guessit/transfo/guess_weak_episodes_rexps.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit import Guess
+from guessit.transfo import SingleNodeGuesser
+from guessit.patterns import weak_episode_rexps
+import re
+import logging
+
+log = logging.getLogger("guessit.transfo.guess_weak_episodes_rexps")
+
+
+def guess_weak_episodes_rexps(string, node):
+    if 'episodeNumber' in node.root.info:
+        return None, None
+
+    for rexp, span_adjust in weak_episode_rexps:
+        match = re.search(rexp, string, re.IGNORECASE)
+        if match:
+            metadata = match.groupdict()
+            span = (match.start() + span_adjust[0],
+                    match.end() + span_adjust[1])
+
+            epnum = int(metadata['episodeNumber'])
+            if epnum > 100:
+                return Guess({ 'season': epnum // 100,
+                               'episodeNumber': epnum % 100 },
+                             confidence=0.6), span
+            else:
+                return Guess(metadata, confidence=0.3), span
+
+    return None, None
+
+
+guess_weak_episodes_rexps.use_node = True
+
+
+def process(mtree):
+    SingleNodeGuesser(guess_weak_episodes_rexps, 0.6, log).process(mtree)

libs/guessit/transfo/guess_website.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit.transfo import SingleNodeGuesser
+from guessit.patterns import websites
+import logging
+
+log = logging.getLogger("guessit.transfo.guess_website")
+
+
+def guess_website(string):
+    low = string.lower()
+    for site in websites:
+        pos = low.find(site.lower())
+        if pos != -1:
+            return {'website': site}, (pos, pos + len(site))
+    return None, None
+
+
+def process(mtree):
+    SingleNodeGuesser(guess_website, 1.0, log).process(mtree)

libs/guessit/transfo/guess_year.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit.transfo import SingleNodeGuesser
+from guessit.date import search_year
+import logging
+
+log = logging.getLogger("guessit.transfo.guess_year")
+
+
+def guess_year(string):
+    year, span = search_year(string)
+    if year:
+        return { 'year': year }, span
+    else:
+        return None, None
+
+
+def process(mtree):
+    SingleNodeGuesser(guess_year, 1.0, log).process(mtree)

libs/guessit/transfo/post_process.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit.patterns import subtitle_exts
+import logging
+
+log = logging.getLogger("guessit.transfo.post_process")
+
+
+def process(mtree):
+    # 1- try to promote language to subtitle language where it makes sense
+    for node in mtree.nodes():
+        if 'language' not in node.guess:
+            continue
+
+        def promote_subtitle():
+            # pylint: disable=W0631
+            node.guess.set('subtitleLanguage', node.guess['language'],
+                           confidence=node.guess.confidence('language'))
+            del node.guess['language']
+
+        # - if we matched a language in a file with a sub extension and that
+        #   the group is the last group of the filename, it is probably the
+        #   language of the subtitle
+        #   (eg: 'xxx.english.srt')
+        if (mtree.node_at((-1,)).value.lower() in subtitle_exts and
+            node == mtree.leaves()[-2]):
+            promote_subtitle()
+
+        # - if a language is in an explicit group just preceded by "st",
+        #   it is a subtitle language (eg: '...st[fr-eng]...')
+        try:
+            idx = node.node_idx
+            previous = mtree.node_at((idx[0], idx[1] - 1)).leaves()[-1]
+            if previous.value.lower()[-2:] == 'st':
+                promote_subtitle()
+        except IndexError:
+            pass
+
+    # 2- ", the" at the end of a series title should be prepended to it
+    for node in mtree.nodes():
+        if 'series' not in node.guess:
+            continue
+
+        series = node.guess['series']
+        lseries = series.lower()
+
+        if lseries[-4:] == ',the':
+            node.guess['series'] = 'The ' + series[:-4]
+
+        if lseries[-5:] == ', the':
+            node.guess['series'] = 'The ' + series[:-5]

libs/guessit/transfo/split_explicit_groups.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit.textutils import find_first_level_groups
+from guessit.patterns import group_delimiters
+import logging
+
+log = logging.getLogger("guessit.transfo.split_explicit_groups")
+
+
+def process(mtree):
+    """return the string split into explicit groups, that is, those either
+    between parenthese, square brackets or curly braces, and those separated
+    by a dash."""
+    for c in mtree.children:
+        groups = find_first_level_groups(c.value, group_delimiters[0])
+        for delimiters in group_delimiters:
+            flatten = lambda l, x: l + find_first_level_groups(x, delimiters)
+            groups = reduce(flatten, groups, [])
+
+        # do not do this at this moment, it is not strong enough and can break other
+        # patterns, such as dates, etc...
+        #groups = reduce(lambda l, x: l + x.split('-'), groups, [])
+
+        c.split_on_components(groups)

libs/guessit/transfo/split_on_dash.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit.patterns import sep
+import re
+import logging
+
+log = logging.getLogger("guessit.transfo.split_on_dash")
+
+
+def process(mtree):
+    for node in mtree.unidentified_leaves():
+        indices = []
+
+        didx = 0
+        pattern = re.compile(sep + '-' + sep)
+        match = pattern.search(node.value)
+        while match:
+            span = match.span()
+            indices.extend([ span[0], span[1] ])
+            match = pattern.search(node.value, span[1])
+
+        didx = node.value.find('-')
+        while didx > 0:
+            if (didx > 10 and
+                (didx - 1 not in indices and
+                 didx + 2 not in indices)):
+
+                indices.extend([ didx, didx + 1 ])
+
+            didx = node.value.find('-', didx + 1)
+
+        if indices:
+            node.partition(indices)

libs/guessit/transfo/split_path_components.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# GuessIt - A library for guessing information from filenames
+# Copyright (c) 2012 Nicolas Wack <wackou@gmail.com>
+#
+# GuessIt is free software; you can redistribute it and/or modify it under
+# the terms of the Lesser GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# GuessIt is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# Lesser GNU General Public License for more details.
+#
+# You should have received a copy of the Lesser GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from guessit import fileutils
+import os.path
+import logging
+
+log = logging.getLogger("guessit.transfo.split_path_components")
+
+
+def process(mtree):
+    """Returns the filename split into [ dir*, basename, ext ]."""
+    components = fileutils.split_path(mtree.value)
+    basename = components.pop(-1)
+    components += list(os.path.splitext(basename))
+    components[-1] = components[-1][1:] # remove the '.' from the extension
+
+    mtree.split_on_components(components)