The error message is pointing to a line in boilerpipe/extract/__init__.py, which makes a call to the unicode built-in function.

I assume the link below is the source code for the package you are using. If so, it appears to be written for Python 2.7, which you can see if you look near the end of this file:

https://github.com/misja/python-boilerpipe/blob/master/setup.py

You have several options as far as I can see:

1. Find a Python 3 port of this package. There are at least a few out there (here's one and here's another).
2. Port the package to Python 3 yourself (if that is the only error, you could simply change that line to use str, but later changes could cause problems with other parts of the package). This official tool should be of assistance; this official guide should, as well.
3. Port you project to Python 2.7 and continue using the same package.

I hope this helps!

Python 3 renamed the unicode type to str, the old str type has been replaced by bytes.

if isinstance(unicode_or_str, str):
    text = unicode_or_str
    decoded = False
else:
    text = unicode_or_str.decode(encoding)
    decoded = True

You may want to read the Python 3 porting HOWTO for more such details. There is also Lennart Regebro's Porting to Python 3: An in-depth guide, free online.

Last but not least, you could just try to use the 2to3 tool to see how that translates the code for you.

in python 3 strings are unicode by default.

Remove the unicode function, replace by str.

https://docs.python.org/3.0/whatsnew/3.0.html#text-vs-data-instead-of-unicode-vs-8-bit

There's also a little recipe to make the code python 2 & 3 compatible:

try:
    unicode        # check if unicode is defined
except NameError:  # not found: python 3: replace by str
    unicode = str

Like Bakuriu said in his comment, never use a bare except:

Prefer:

except Exception as e:
    print("Problem "+repr(e))
    # the line below requires some HTML normalization or resulting
    # html could be incorrect
    import re
    ne = re.sub("[^\w]"," ",str(e))
    self.browser.append("<font color=red>"+ne+"</font>")

Now you have the real/next exception displayed.

unicode(sub, "UTF-8")

should be

sub.decode("UTF-8")

Python3 unified the str and unicode types so there's no longer a builtin unicode cast operator.

The Python 3 Unicode HOWTO explains a lot of the differences.

Since Python 3.0, the language features a str type that contain Unicode characters, meaning any string created using "unicode rocks!", 'unicode rocks!', or the triple-quoted string syntax is stored as Unicode.

and explains how encode and decode relate to one another

Converting to Bytes

The opposite method of bytes.decode() is str.encode(), which returns a bytes representation of the Unicode string, encoded in the requested encoding.

Instead of

file(...)

use open

The I/O docs explain how to use open and how to use with to make sure it gets closed.

It is good practice to use the with keyword when dealing with file objects. This has the advantage that the file is properly closed after its suite finishes, even if an exception is raised on the way. It is also much shorter than writing equivalent try-finally blocks:

 >>> with open('workfile', 'r') as f:
 ...     read_data = f.read()
 >>> f.closed
 True

unicode is a python 2 method. If you are not sure which version will run this code, you can simply add this at the beginning of your code so it will replace the old unicode with new str:

import sys
if sys.version_info[0] >= 3:
    unicode = str

There is no such name in Python 3, no. You are trying to run Python 2 code in Python 3. In Python 3, unicode has been renamed to str.

However, you can remove the unicode() call altogether; open() produces a file object that already decodes data to Unicode for you. You probably want to tell it what codec to use, explicitly:

fileMain = open("dictionary_15k.txt", "r", encoding="utf-8")
for line1 in fileMain:
    dictWords.append(line1.strip())

You may want to switch to Python 2 if your tutorial is written with that version in mind.

I suspect that code snippet must be for Python 2, for which unicode() was a built-in function ready to be used without an import. In Python 3, literal strings are Unicode by default, so you don't need to explicitly cast them.

As has already been pointed out in the comments, there is already advice on porting from 2 to 3.

Having recently had to port some of my own code from 2 to 3 and maintain compatibility for each for now, I wholeheartedly recommend using python-future, which provides a great tool to help update your code (futurize) as well as clear guidance for how to write cross-compatible code.

In your specific case, I would simply convert all calls to unicode to use str and then import str from builtins. Any IDE worth its salt these days will do that global search and replace in one operation.

Of course, that's the sort of thing futurize should catch too, if you just want to use automatic conversion (and to look for other potential issues in your code).