How to use the guessit.plugins.transformers.Transformer function in guessit

def __init__(self):
        Transformer.__init__(self, 20)

        range_separators = ['-', 'to', 'a']
        discrete_separators = ['&', 'and', 'et']
        of_separators = ['of', 'sur', '/', '\\']

        season_words = ['seasons?', 'saisons?', 'series?']
        episode_words = ['episodes?']

        season_markers = ['s']
        episode_markers = ['e', 'ep']

        discrete_sep = sep
        for range_separator in range_separators:
            discrete_sep = discrete_sep.replace(range_separator, '')
        discrete_separators.append(discrete_sep)
        all_separators = list(range_separators)

# 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 .
#

from __future__ import absolute_import, division, print_function, unicode_literals

from guessit.language import search_language, subtitle_prefixes, subtitle_suffixes
from guessit.patterns.extension import subtitle_exts
from guessit.textutils import find_words
from guessit.plugins.transformers import Transformer
from guessit.matcher import GuessFinder


class GuessLanguage(Transformer):
    def __init__(self):
        Transformer.__init__(self, 30)

    def register_arguments(self, opts, naming_opts, output_opts, information_opts, webservice_opts, other_options):
        naming_opts.add_argument('-L', '--allowed-languages', action='append', dest='allowed_languages',
                               help='Allowed language (can be used multiple times)')

    def supported_properties(self):
        return ['language', 'subtitleLanguage']

    @staticmethod
    def guess_language(string, node=None, options=None):
        allowed_languages = None
        if options and 'allowed_languages' in options:
            allowed_languages = options.get('allowed_languages')

#

from __future__ import absolute_import, division, print_function, unicode_literals

import re
from guessit.patterns.list import list_parser, all_separators_re

from guessit.plugins.transformers import Transformer
from guessit.matcher import GuessFinder
from guessit.patterns import sep, build_or_pattern
from guessit.containers import PropertiesContainer, WeakValidator, NoValidator, ChainedValidator, DefaultValidator, \
    FormatterValidator
from guessit.patterns.numeral import numeral, digital_numeral, parse_numeral


class GuessEpisodesRexps(Transformer):
    def __init__(self):
        Transformer.__init__(self, 20)

        of_separators = ['of', 'sur', '/', '\\']
        of_separators_re = re.compile(build_or_pattern(of_separators, escape=True), re.IGNORECASE)

        season_words = ['seasons?', 'saisons?', 'series?']
        episode_words = ['episodes?']

        season_markers = ['s']
        episode_markers = ['e', 'ep']

        self.container = PropertiesContainer(enhance=False, canonical_from_pattern=False)

        season_words_re = re.compile(build_or_pattern(season_words), re.IGNORECASE)
        episode_words_re = re.compile(build_or_pattern(episode_words), re.IGNORECASE)

# 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 .
#

from __future__ import absolute_import, division, print_function, unicode_literals
from guessit.containers import DefaultValidator

from guessit.plugins.transformers import Transformer
from guessit.matcher import GuessFinder
from guessit.date import search_date


class GuessDate(Transformer):
    def __init__(self):
        Transformer.__init__(self, 50)

    def register_arguments(self, opts, naming_opts, output_opts, information_opts, webservice_opts, other_options):
        naming_opts.add_argument('-Y', '--date-year-first', action='store_true', dest='date_year_first', default=None,
                                 help='If short date is found, consider the first digits as the year.')
        naming_opts.add_argument('-D', '--date-day-first', action='store_true', dest='date_day_first', default=None,
                                 help='If short date is found, consider the second digits as the day.')

    def supported_properties(self):
        return ['date']

    @staticmethod
    def guess_date(string, node=None, options=None):
        date, span = search_date(string, options.get('date_year_first') if options else False, options.get('date_day_first') if options else False)
        if date and span and DefaultValidator.validate_string(string, span): # ensure we have a separator before and after date

# 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 .
#

from __future__ import absolute_import, division, print_function, unicode_literals

from guessit.plugins.transformers import Transformer
from guessit.matcher import GuessFinder
import re


class GuessIdnumber(Transformer):
    def __init__(self):
        Transformer.__init__(self, -180)

    def supported_properties(self):
        return ['idNumber']

    _idnum = re.compile(r'(?P[a-zA-Z0-9-]{20,})')  # 1.0, (0, 0))

    def guess_idnumber(self, string, node=None, options=None):
        match = self._idnum.search(string)
        if match is not None:
            result = match.groupdict()
            switch_count = 0
            DIGIT = 0
            LETTER = 1
            OTHER = 2

# 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 .
#

from __future__ import absolute_import, division, print_function, unicode_literals

from os.path import splitext

from guessit.plugins.transformers import Transformer
from guessit import fileutils


class SplitPathComponents(Transformer):
    def __init__(self):
        Transformer.__init__(self, 255)

    def process(self, mtree, options=None):
        """first split our path into dirs + basename + ext

        :return: the filename split into [ dir*, basename, ext ]
        """
        if not options.get('name_only'):
            components = fileutils.split_path(mtree.value)
            basename = components.pop(-1)
            components += list(splitext(basename))
            components[-1] = components[-1][1:]  # remove the '.' from the extension

            mtree.split_on_components(components, category='path')
        else:

def __init__(self):
        Transformer.__init__(self, 225)

#
# You should have received a copy of the Lesser GNU General Public License
# along with this program.  If not, see .
#

from __future__ import absolute_import, division, print_function, unicode_literals

from guessit.plugins.transformers import Transformer, get_transformer
from guessit.textutils import reorder_title

from guessit.matcher import found_property
from guessit.patterns.list import all_separators
from guessit.language import all_lang_prefixes_suffixes


class GuessEpisodeInfoFromPosition(Transformer):
    def __init__(self):
        Transformer.__init__(self, -200)

    def supported_properties(self):
        return ['title', 'series']

    @staticmethod
    def excluded_word(*values):
        for value in values:
            if value.clean_value.lower() in (all_separators + all_lang_prefixes_suffixes):
                return True
        return False

    def match_from_epnum_position(self, path_node, ep_node, options):
        epnum_idx = ep_node.node_idx

import logging

from guessit.plugins.transformers import Transformer
from babelfish import Country
from guessit import Guess
from guessit.textutils import iter_words
from guessit.matcher import GuessFinder, found_guess
from guessit.language import LNG_COMMON_WORDS
import babelfish


log = logging.getLogger(__name__)


class GuessCountry(Transformer):
    def __init__(self):
        Transformer.__init__(self, -170)
        self.replace_language = frozenset(['uk'])

    def register_arguments(self, opts, naming_opts, output_opts, information_opts, webservice_opts, other_options):
        naming_opts.add_argument('-C', '--allowed-country', action='append', dest='allowed_countries',
                                 help='Allowed country (can be used multiple times)')

    def supported_properties(self):
        return ['country']

    def should_process(self, mtree, options=None):
        options = options or {}
        return options.get('country', True)

    @staticmethod