How to use the revscoring.dependencies.solve function in revscoring

def test_dictionary():
    cache = {revision_oriented.revision.text:
             'obrębie znamion barwnikowych  worngly.'}
    assert (solve(polish.dictionary.revision.datasources.dict_words, cache=cache) ==
            ["obrębie", "znamion", "barwnikowych"])
    assert (solve(polish.dictionary.revision.datasources.non_dict_words,
                  cache=cache) ==
            ["worngly"])

    assert polish.dictionary == pickle.loads(pickle.dumps(polish.dictionary))

def test_stopwords():
    cache = {r_text: 'Αυτό είναι γραμμένο λθος. '}
    assert (solve(greek.stopwords.revision.datasources.stopwords, cache=cache) ==
            ["Αυτό", "είναι"])
    assert (solve(greek.stopwords.revision.datasources.non_stopwords,
                  cache=cache) ==
            ["γραμμένο", "λθος"])

    assert greek.stopwords == pickle.loads(pickle.dumps(greek.stopwords))

def test_dictionary():
    cache = {revision_oriented.revision.text:
             'novirze no ilggadējiem vidējiem  worngly.'}
    assert (solve(latvian.dictionary.revision.datasources.dict_words, cache=cache) ==
            ["novirze", "no", "ilggadējiem", "vidējiem"])
    assert (solve(latvian.dictionary.revision.datasources.non_dict_words,
                  cache=cache) ==
            ["worngly"])

    assert latvian.dictionary == pickle.loads(pickle.dumps(latvian.dictionary))

def test_dictionary():
    cache = {r_text: 'This color colour is spelled worngly. '}
    assert (solve(english.dictionary.revision.datasources.dict_words, cache=cache) ==
            ["This", "color", "colour", "is", "spelled"])
    assert (solve(english.dictionary.revision.datasources.non_dict_words,
                  cache=cache) ==
            ["worngly"])

    assert english.dictionary == pickle.loads(pickle.dumps(english.dictionary))

def test_dictionary():
    cache = {r_text: 'Αυτό είναι γραμμένο λθος. '}
    assert (solve(greek.dictionary.revision.datasources.dict_words, cache=cache) ==
            ["Αυτό", "είναι", "γραμμένο"])
    assert (solve(greek.dictionary.revision.datasources.non_dict_words,
                  cache=cache) ==
            ["λθος"])

    assert greek.dictionary == pickle.loads(pickle.dumps(greek.dictionary))

def test_stopwords():
    cache = {r_text: "Est un projet principe du worngly. "}
    assert (solve(french.stopwords.revision.datasources.stopwords, cache=cache) ==
            ["Est", "un", "du"])
    assert (solve(french.stopwords.revision.datasources.non_stopwords,
                  cache=cache) ==
            ["projet", "principe", "worngly"])

    assert french.stopwords == pickle.loads(pickle.dumps(french.stopwords))

def test_dictionary():
    cache = {r_text: "Tal olid nooremad, vennad worngly. "}
    assert solve(estonian.dictionary.revision.datasources.dict_words,
                 cache=cache) == ["Tal", "olid", "nooremad", "vennad"]
    assert solve(estonian.dictionary.revision.datasources.non_dict_words,
                 cache=cache) == ["worngly"]

    assert estonian.dictionary == pickle.loads(
        pickle.dumps(estonian.dictionary))

def test_dictionary():
    cache = {r_text: 'belgíska konungsríkisins auk worngly. '}
    assert (solve(icelandic.dictionary.revision.datasources.dict_words,
                  cache=cache) ==
            ["belgíska", "konungsríkisins", "auk"])
    assert (solve(icelandic.dictionary.revision.datasources.non_dict_words,
                  cache=cache) ==
            ["worngly"])

    assert icelandic.dictionary == pickle.loads(
        pickle.dumps(icelandic.dictionary))

def test_stopwords():
    cache = {
        revision_oriented.revision.text:
            'játszótérnek még helyett park jól'
    }
    assert (solve(hungarian.stopwords.revision.datasources.stopwords,
            cache=cache) == ['még', 'jól'])
    assert (solve(hungarian.stopwords.revision.datasources.non_stopwords,
                  cache=cache) ==
            ['játszótérnek', 'helyett', 'park'])

    assert hungarian.stopwords == pickle.loads(
        pickle.dumps(hungarian.stopwords))

def score_text(model, text):
    try:
        feature_values = list(solve(model.features, cache={r_text: text}))
        return None, model.score(feature_values)
    except Exception as e:
        return e, None