Adapted from the cpython source:

https://github.com/python/cpython/blob/01fd68752e2d2d0a5f90ae8944ca35df0a5ddeaa/Lib/unittest/case.py#L1091

import difflib
import pprint

def compare_dicts(d1, d2):
    return ('\n' + '\n'.join(difflib.ndiff(
                   pprint.pformat(d1).splitlines(),
                   pprint.pformat(d2).splitlines())))

Your code seems legit. I did a couple of little tweaks that would shave off a couple of microseconds per loop:

1. No need for the two sorted calls because difflib can calculate an order-indifferent comparison with quick_ratio (Checkout the documentation here for the difference between ratio, quick_ratio, and real_quick_ratio).
2. No need for the enumerate to access mat by i and j.
3. Removed the access of the list through index first_dict[index] and second_dict[index]

def naive_ratio_comparison(first_dict, second_dict):
    mat = []
    for second in second_dict.values():
        for first in first_dict.values():
            sm = difflib.SequenceMatcher(None, first, second)
            mat.append(sm.quick_ratio())
    result = np.resize(mat, (len(second_dict), len(first_dict)))
    return result

Using difflib is probably the best choice. So the problem comes down to the size of your word list. If we can pare down the number of words difflib needs to compare, then we could get a faster time.

One idea to implement, is take only words that are near-enough in length:

# Returns the min and max thresholds for word length
def get_thresholds(word, min=3, max=3):
    length = len(word)
    return max(1, length-min), length+max 

# Returns only words whose length is within a certain range
def filter_word_list(min, max):
    return [word for word in words_list if min <= len(word) <= max]

So the call to get_close_matches() would be:

closeMatches = difflib.get_close_matches(termL,
                       dictionaryFile.filter_word_list(*get_thresholds(termL)))

Another idea would be to filter words that begin with a letter that is spatially related to the word's first letter on the keyboard. However, this suggestion is not as plausible due to different keyboard layouts.

As some general comments:

1. Take a look at your variable names. They are descriptive (for the most part) but the official Python style guide recommends using underscores_between_words instead of camelCaseNames.

2. Same basic idea for module names. Pythonic module names are written as MyModule instead of myModule. Also, each different module import gets its own line:

   # Not `import os, sys`
   import os
   import sys
   

You have a few issues here. First off, you're trying to use the method difflib.Differ.compare, but you're calling it as a plain function - you have not actually created a difflib.Differ object.

Second, this compare method expects you to operate upon a sequence of strings (for each of the two things being compared). Your convert function is sometimes returning strings, sometimes dicts, sometimes other stuff... in general, you're not getting back sequences of strings.

The natural way to get what you want is to just compare the actual JSON data, because that's a string. However, there are two issues there:

• you want a sequence of strings (line-by-line) instead of a single string with the whole JSON document, but that's trivial - just split it up into lines with the string .splitlines method.

• your input might have differences in whitespace that you want to ignore. The simple way around this is to, after loading each JSON document into an object, re-create a string for it with dumps. The idea is that for both documents that you're comparing, you will dump with the same whitespace settings. You need to read the documentation and decide what settings you want to use.