human
Complete this python program:
def extractWithoutOrder(query, choices, processor=default_processor, scorer=default_scorer, score_cutoff=0):
assistant
#Here is the Python code you requested.

    """Select the best match in a list or dictionary of choices.
    Find best matches in a list or dictionary of choices, return a
    generator of tuples containing the match and its score. If a dictionary
    is used, also returns the key for each match.
    Arguments:
    query: An object representing the thing we want to find.
    choices: An iterable or dictionary-like object containing choices
    to be matched against the query. Dictionary arguments of
    {key: value} pairs will attempt to match the query against
    each value.
    processor: Optional function of the form f(a) -> b, where a is the query or
    individual choice and b is the choice to be used in matching.
    This can be used to match against, say, the first element of
    a list:
    lambda x: x[0]
    Defaults to fuzzywuzzy.utils.full_process().
    scorer: Optional function for scoring matches between the query and
    an individual processed choice. This should be a function
    of the form f(query, choice) -> int.
    By default, fuzz.WRatio() is used and expects both query and
    choice to be strings.
    score_cutoff: Optional argument for score threshold. No matches with
    a score less than this number will be returned. Defaults to 0.
    Returns:
    Generator of tuples containing the match and its score.
    If a list is used for choices, then the result will be 2-tuples.
    If a dictionary is used, then the result will be 3-tuples containing
    the key for each match.
    For example, searching for \bird\ in the dictionary
    {\bard\: \train\, \dog\: \man\}
    may return
    (\train\, 22, \bard\), (\man\, 0, \dog\)
    """
    def no_process(x):
        return x
    try:
        if ((choices is None) or (len(choices) == 0)):
            raise StopIteration
    except TypeError:
        pass
    if (processor is None):
        processor = no_process
    processed_query = processor(query)
    if (len(processed_query) == 0):
        logging.warning(u"Applied    processor    reduces    input    query    to    empty    string,    all    comparisons    will    have    score    0.    [Query:    '{0}']".format(query))
    if ((scorer in [fuzz.WRatio, fuzz.QRatio, fuzz.token_set_ratio, fuzz.token_sort_ratio, fuzz.partial_token_set_ratio, fuzz.partial_token_sort_ratio, fuzz.UWRatio, fuzz.UQRatio]) and (processor == utils.full_process)):
        processor = no_process
    if (scorer in [fuzz.UWRatio, fuzz.UQRatio]):
        pre_processor = partial(utils.full_process, force_ascii=False)
        scorer = partial(scorer, full_process=False)
    elif (scorer in [fuzz.WRatio, fuzz.QRatio, fuzz.token_set_ratio, fuzz.token_sort_ratio, fuzz.partial_token_set_ratio, fuzz.partial_token_sort_ratio]):
        pre_processor = partial(utils.full_process, force_ascii=True)
        scorer = partial(scorer, full_process=False)
    else:
        pre_processor = no_process
    processed_query = pre_processor(processed_query)
    try:
        for (key, choice) in choices.items():
            processed = pre_processor(processor(choice))
            score = scorer(processed_query, processed)
            if (score >= score_cutoff):
                (yield (choice, score, key))
    except AttributeError:
        for choice in choices:
            processed = pre_processor(processor(choice))
            score = scorer(processed_query, processed)
            if (score >= score_cutoff):
                (yield (choice, score))