diff -ru mythes-en-3.0/wn2ooo/wn2ooo.py mythes-en-3.0.fixed/wn2ooo/wn2ooo.py

--- mythes-en-3.0/wn2ooo/wn2ooo.py	2005-07-23 23:21:20.000000000 +0100

+++ mythes-en-3.0.fixed/wn2ooo/wn2ooo.py	2018-07-30 14:46:52.695201526 +0100

@@ -65,7 +65,7 @@

 				entry = getRelatedTerms(u, HYPERNYM, '')

 			try:

 				listpos = l.index(entry)

-			except ValueError, e:

+			except ValueError as e:

 				l.append(entry)

 	return str.join("|", l)

@@ -74,12 +74,12 @@

 	for word in words:

 		l = []

 		if c % 100 == 0:

-			print >> sys.stderr, "Working on word %d" % c

+			print("Working on word %d" % c, file=sys.stderr)

 		for pos in [ADJ, N, V, ADV]:

 			try:

 				for s in pos[word].getSenses():

 					l.append(s)

-			except KeyError, e:

+			except KeyError as e:

 				#print >> sys.stderr, e

 				continue

 		syn_count = 0

@@ -118,7 +118,7 @@

 					syn_lines = "%s%s" % (syn_lines, more_generic_terms)

 				syn_count = syn_count + 1

 		if syn_count > 0:

-			print "%s|%d\n%s" % (word, syn_count, syn_lines)

+			print("%s|%d\n%s" % (word, syn_count, syn_lines))

 		c = c + 1

 	return

@@ -132,40 +132,38 @@

 	return s

 def main():

-	print "ISO8859-1"

+	print("ISO8859-1")

 	words = {}

 	dic = Dictionary(ADJECTIVE, "adj")

-	for w in dic.keys():

+	for w in list(dic.keys()):

 		words[w] = None

 	dic = Dictionary(NOUN, "noun")

-	for w in dic.keys():

+	for w in list(dic.keys()):

 		words[w] = None

 	dic = Dictionary(VERB, "verb")

-	for w in dic.keys():

+	for w in list(dic.keys()):

 		words[w] = None

 	dic = Dictionary(ADVERB, "adv")

-	for w in dic.keys():

+	for w in list(dic.keys()):

 		words[w] = None

-	words = words.keys()

+	words = list(words.keys())

 	# tests:

 	#words = ['dog', 'house', 'nullipara']

 	#words = ['absent', 'whistle stop']

 	#words = ['war']

-	print >>sys.stderr, "Dictionaries contain %d words" % len(words)

-	print >>sys.stderr, "Sorting..."

-	words.sort(mycompare)

+	print("Dictionaries contain %d words" % len(words), file=sys.stderr)

+	print("Sorting...", file=sys.stderr)

+	words = sorted(words, key=mycompare)

 	printSynsForWords(words)

 	return

-def mycompare(a, b):

+def mycompare(elem):

 	# stupid hack to make sure the list is sorted like Kevin's original list:

-	a = a.replace(" ", "Z")

-	b = b.replace(" ", "Z")

-	return cmp(a, b)

+	return elem.replace(" ", "Z")

 main()

diff -ru mythes-en-3.0/wn2ooo/wordnet.py mythes-en-3.0.fixed/wn2ooo/wordnet.py

--- mythes-en-3.0/wn2ooo/wordnet.py	2005-07-23 23:21:16.000000000 +0100

+++ mythes-en-3.0.fixed/wn2ooo/wordnet.py	2018-07-30 14:46:52.695201526 +0100

@@ -44,7 +44,6 @@

 import string

 import os

 from os import environ

-from types import IntType, ListType, StringType, TupleType

 #

@@ -212,15 +211,15 @@

     def __init__(self, line):

         """Initialize the word from a line of a WN POS file."""

-	tokens = string.split(line)

-	ints = map(int, tokens[int(tokens[3]) + 4:])

-	self.form = string.replace(tokens[0], '_', ' ')

+        tokens = line.split()

+        ints = list(map(int, tokens[int(tokens[3]) + 4:]))

+        self.form = tokens[0].replace('_', ' ')

         "Orthographic representation of the word."

-	self.pos = _normalizePOS(tokens[1])

+        self.pos = _normalizePOS(tokens[1])

         "Part of speech.  One of NOUN, VERB, ADJECTIVE, ADVERB."

-	self.taggedSenseCount = ints[1]

+        self.taggedSenseCount = ints[1]

         "Number of senses that are tagged."

-	self._synsetOffsets = ints[2:ints[0]+2]

+        self._synsetOffsets = ints[2:ints[0]+2]

     def getPointers(self, pointerType=None):

         """Pointers connect senses and synsets, not words.

@@ -233,17 +232,17 @@

         raise self.getPointers.__doc__

     def getSenses(self):

-	"""Return a sequence of senses.

-	

-	>>> N['dog'].getSenses()

-	('dog' in {noun: dog, domestic dog, Canis familiaris}, 'dog' in {noun: frump, dog}, 'dog' in {noun: dog}, 'dog' in {noun: cad, bounder, blackguard, dog, hound, heel}, 'dog' in {noun: frank, frankfurter, hotdog, hot dog, dog, wiener, wienerwurst, weenie}, 'dog' in {noun: pawl, detent, click, dog}, 'dog' in {noun: andiron, firedog, dog, dog-iron})

-	"""

-	if not hasattr(self, '_senses'):

-	    def getSense(offset, pos=self.pos, form=self.form):

-		return getSynset(pos, offset)[form]

-	    self._senses = tuple(map(getSense, self._synsetOffsets))

-	    del self._synsetOffsets

-	return self._senses

+        """Return a sequence of senses.

+        

+        >>> N['dog'].getSenses()

+        ('dog' in {noun: dog, domestic dog, Canis familiaris}, 'dog' in {noun: frump, dog}, 'dog' in {noun: dog}, 'dog' in {noun: cad, bounder, blackguard, dog, hound, heel}, 'dog' in {noun: frank, frankfurter, hotdog, hot dog, dog, wiener, wienerwurst, weenie}, 'dog' in {noun: pawl, detent, click, dog}, 'dog' in {noun: andiron, firedog, dog, dog-iron})

+        """

+        if not hasattr(self, '_senses'):

+            def getSense(offset, pos=self.pos, form=self.form):

+                return getSynset(pos, offset)[form]

+            self._senses = tuple(map(getSense, self._synsetOffsets))

+            del self._synsetOffsets

+        return self._senses

     # Deprecated.  Present for backwards compatability.

     def senses(self):

@@ -255,70 +254,70 @@

         return self.getSense()

     def isTagged(self):

-	"""Return 1 if any sense is tagged.

-	

-	>>> N['dog'].isTagged()

-	1

-	"""

-	return self.taggedSenseCount > 0

+        """Return 1 if any sense is tagged.

+        

+        >>> N['dog'].isTagged()

+        1

+        """

+        return self.taggedSenseCount > 0

     def getAdjectivePositions(self):

-	"""Return a sequence of adjective positions that this word can

-	appear in.  These are elements of ADJECTIVE_POSITIONS.

-	

-	>>> ADJ['clear'].getAdjectivePositions()

-	[None, 'predicative']

-	"""

-	positions = {}

-	for sense in self.getSenses():

-	    positions[sense.position] = 1

-	return positions.keys()

+        """Return a sequence of adjective positions that this word can

+        appear in.  These are elements of ADJECTIVE_POSITIONS.

+        

+        >>> ADJ['clear'].getAdjectivePositions()

+        [None, 'predicative']

+        """

+        positions = {}

+        for sense in self.getSenses():

+            positions[sense.position] = 1

+        return list(positions.keys())

     adjectivePositions = getAdjectivePositions # backwards compatability

     def __cmp__(self, other):

-	"""

-	>>> N['cat'] < N['dog']

-	1

-	>>> N['dog'] < V['dog']

-	1

-	"""

-	return _compareInstances(self, other, ('pos', 'form'))

+        """

+        >>> N['cat'] < N['dog']

+        1

+        >>> N['dog'] < V['dog']

+        1

+        """

+        return _compareInstances(self, other, ('pos', 'form'))

     def __str__(self):

-	"""Return a human-readable representation.

-	

-	>>> str(N['dog'])

-	'dog(n.)'

-	"""

-	abbrs = {NOUN: 'n.', VERB: 'v.', ADJECTIVE: 'adj.', ADVERB: 'adv.'}

-	return self.form + "(" + abbrs[self.pos] + ")"

+        """Return a human-readable representation.

+        

+        >>> str(N['dog'])

+        'dog(n.)'

+        """

+        abbrs = {NOUN: 'n.', VERB: 'v.', ADJECTIVE: 'adj.', ADVERB: 'adv.'}

+        return self.form + "(" + abbrs[self.pos] + ")"

     def __repr__(self):

-	"""If ReadableRepresentations is true, return a human-readable

-	representation, e.g. 'dog(n.)'.

-	

-	If ReadableRepresentations is false, return a machine-readable

-	representation, e.g. "getWord('dog', 'noun')".

-	"""

-	if ReadableRepresentations:

-	    return str(self)

-	return "getWord" + `(self.form, self.pos)`

-	

+        """If ReadableRepresentations is true, return a human-readable

+        representation, e.g. 'dog(n.)'.

+        

+        If ReadableRepresentations is false, return a machine-readable

+        representation, e.g. "getWord('dog', 'noun')".

+        """

+        if ReadableRepresentations:

+            return str(self)

+        return "getWord" + repr((self.form, self.pos))

+        

     #

     # Sequence protocol (a Word's elements are its Senses)

     #

-    def __nonzero__(self):

-	return 1

+    def __bool__(self):

+        return 1

     def __len__(self):

-	return len(self.getSenses())

+        return len(self.getSenses())

     def __getitem__(self, index):

-	return self.getSenses()[index]

+        return self.getSenses()[index]

     def __getslice__(self, i, j):

-	return self.getSenses()[i:j]

+        return self.getSenses()[i:j]

 class Synset:

@@ -356,157 +355,157 @@

     def __init__(self, pos, offset, line):

         "Initialize the synset from a line off a WN synset file."

-	self.pos = pos

+        self.pos = pos

         "part of speech -- one of NOUN, VERB, ADJECTIVE, ADVERB."

-	self.offset = offset

+        self.offset = offset

         """integer offset into the part-of-speech file.  Together

         with pos, this can be used as a unique id."""

-	tokens = string.split(line[:string.index(line, '|')])

-	self.ssType = tokens[2]

-	self.gloss = string.strip(line[string.index(line, '|') + 1:])

+        tokens = line[:line.index('|')].split()

+        self.ssType = tokens[2]

+        self.gloss = line[line.index('|') + 1:].strip()

         self.lexname = Lexname.lexnames[int(tokens[1])]

-	(self._senseTuples, remainder) = _partition(tokens[4:], 2, string.atoi(tokens[3], 16))

-	(self._pointerTuples, remainder) = _partition(remainder[1:], 4, int(remainder[0]))

-	if pos == VERB:

-	    (vfTuples, remainder) = _partition(remainder[1:], 3, int(remainder[0]))

-	    def extractVerbFrames(index, vfTuples):

-		return tuple(map(lambda t:string.atoi(t[1]), filter(lambda t,i=index:string.atoi(t[2],16) in (0, i), vfTuples)))

-	    senseVerbFrames = []

-	    for index in range(1, len(self._senseTuples) + 1):

-		senseVerbFrames.append(extractVerbFrames(index, vfTuples))

-	    self._senseVerbFrames = senseVerbFrames

-	    self.verbFrames = tuple(extractVerbFrames(None, vfTuples))

+        (self._senseTuples, remainder) = _partition(tokens[4:], 2, int(tokens[3], 16))

+        (self._pointerTuples, remainder) = _partition(remainder[1:], 4, int(remainder[0]))

+        if pos == VERB:

+            (vfTuples, remainder) = _partition(remainder[1:], 3, int(remainder[0]))

+            def extractVerbFrames(index, vfTuples):

+                return tuple([int(t[1]) for t in list(filter(lambda t,i=index:int(t[2],16) in (0, i), vfTuples))])

+            senseVerbFrames = []

+            for index in range(1, len(self._senseTuples) + 1):

+                senseVerbFrames.append(extractVerbFrames(index, vfTuples))

+            self._senseVerbFrames = senseVerbFrames

+            self.verbFrames = tuple(extractVerbFrames(None, vfTuples))

             """A sequence of integers that index into

             VERB_FRAME_STRINGS. These list the verb frames that any

             Sense in this synset participates in.  (See also

             Sense.verbFrames.) Defined only for verbs."""

     def getSenses(self):

-	"""Return a sequence of Senses.

-	

-	>>> N['dog'][0].getSenses()

-	('dog' in {noun: dog, domestic dog, Canis familiaris},)

-	"""

-	if not hasattr(self, '_senses'):

-	    def loadSense(senseTuple, verbFrames=None, synset=self):

-		return Sense(synset, senseTuple, verbFrames)

-	    if self.pos == VERB:

-		self._senses = tuple(map(loadSense, self._senseTuples, self._senseVerbFrames))

-		del self._senseVerbFrames

-	    else:

-		self._senses = tuple(map(loadSense, self._senseTuples))

-	    del self._senseTuples

-	return self._senses

+        """Return a sequence of Senses.

+        

+        >>> N['dog'][0].getSenses()

+        ('dog' in {noun: dog, domestic dog, Canis familiaris},)

+        """

+        if not hasattr(self, '_senses'):

+            def loadSense(senseTuple, verbFrames=None, synset=self):

+                return Sense(synset, senseTuple, verbFrames)

+            if self.pos == VERB:

+                self._senses = tuple(map(loadSense, self._senseTuples, self._senseVerbFrames))

+                del self._senseVerbFrames

+            else:

+                self._senses = tuple(map(loadSense, self._senseTuples))

+            del self._senseTuples

+        return self._senses

     senses = getSenses

     def getPointers(self, pointerType=None):

-	"""Return a sequence of Pointers.

+        """Return a sequence of Pointers.

         If pointerType is specified, only pointers of that type are

         returned.  In this case, pointerType should be an element of

         POINTER_TYPES.

-	

-	>>> N['dog'][0].getPointers()[:5]

-	(hypernym -> {noun: canine, canid}, member meronym -> {noun: Canis, genus Canis}, member meronym -> {noun: pack}, hyponym -> {noun: pooch, doggie, doggy, barker, bow-wow}, hyponym -> {noun: cur, mongrel, mutt})

-	>>> N['dog'][0].getPointers(HYPERNYM)

-	(hypernym -> {noun: canine, canid},)

-	"""

-	if not hasattr(self, '_pointers'):

-	    def loadPointer(tuple, synset=self):

-		return Pointer(synset.offset, tuple)

-	    self._pointers = tuple(map(loadPointer, self._pointerTuples))

-	    del self._pointerTuples

-	if pointerType == None:

-	    return self._pointers

-	else:

-	    _requirePointerType(pointerType)

-	    return filter(lambda pointer, type=pointerType: pointer.type == type, self._pointers)

+        

+        >>> N['dog'][0].getPointers()[:5]

+        (hypernym -> {noun: canine, canid}, member meronym -> {noun: Canis, genus Canis}, member meronym -> {noun: pack}, hyponym -> {noun: pooch, doggie, doggy, barker, bow-wow}, hyponym -> {noun: cur, mongrel, mutt})

+        >>> N['dog'][0].getPointers(HYPERNYM)

+        (hypernym -> {noun: canine, canid},)

+        """

+        if not hasattr(self, '_pointers'):

+            def loadPointer(tuple, synset=self):

+                return Pointer(synset.offset, tuple)

+            self._pointers = tuple(map(loadPointer, self._pointerTuples))

+            del self._pointerTuples

+        if pointerType == None:

+            return self._pointers

+        else:

+            _requirePointerType(pointerType)

+            return list(filter(lambda pointer, type=pointerType: pointer.type == type, self._pointers))

     pointers = getPointers # backwards compatability

     def getPointerTargets(self, pointerType=None):

-	"""Return a sequence of Senses or Synsets.

-	

+        """Return a sequence of Senses or Synsets.

+        

         If pointerType is specified, only targets of pointers of that

         type are returned.  In this case, pointerType should be an

         element of POINTER_TYPES.

-	

-	>>> N['dog'][0].getPointerTargets()[:5]

-	[{noun: canine, canid}, {noun: Canis, genus Canis}, {noun: pack}, {noun: pooch, doggie, doggy, barker, bow-wow}, {noun: cur, mongrel, mutt}]

-	>>> N['dog'][0].getPointerTargets(HYPERNYM)

-	[{noun: canine, canid}]

-	"""

-	return map(Pointer.target, self.getPointers(pointerType))

+        

+        >>> N['dog'][0].getPointerTargets()[:5]

+        [{noun: canine, canid}, {noun: Canis, genus Canis}, {noun: pack}, {noun: pooch, doggie, doggy, barker, bow-wow}, {noun: cur, mongrel, mutt}]

+        >>> N['dog'][0].getPointerTargets(HYPERNYM)

+        [{noun: canine, canid}]

+        """

+        return list(map(Pointer.target, self.getPointers(pointerType)))

     pointerTargets = getPointerTargets # backwards compatability

     def isTagged(self):

-	"""Return 1 if any sense is tagged.

-	

-	>>> N['dog'][0].isTagged()

-	1

-	>>> N['dog'][1].isTagged()

-	0

-	"""

-	return len(filter(Sense.isTagged, self.getSenses())) > 0

+        """Return 1 if any sense is tagged.

+        

+        >>> N['dog'][0].isTagged()

+        1

+        >>> N['dog'][1].isTagged()

+        0

+        """

+        return len(list(filter(Sense.isTagged, self.getSenses()))) > 0

     def __str__(self):

-	"""Return a human-readable representation.

-	

-	>>> str(N['dog'][0].synset)

-	'{noun: dog, domestic dog, Canis familiaris}'

-	"""

-	return "{" + self.pos + ": " + string.joinfields(map(lambda sense:sense.form, self.getSenses()), ", ") + "}"

+        """Return a human-readable representation.

+        

+        >>> str(N['dog'][0].synset)

+        '{noun: dog, domestic dog, Canis familiaris}'

+        """

+        return "{" + self.pos + ": " + string.joinfields([sense.form for sense in self.getSenses()], ", ") + "}"

     def __repr__(self):

-	"""If ReadableRepresentations is true, return a human-readable

-	representation, e.g. 'dog(n.)'.

-	

-	If ReadableRepresentations is false, return a machine-readable

-	representation, e.g. "getSynset(pos, 1234)".

-	"""

-	if ReadableRepresentations:

-	    return str(self)

-	return "getSynset" + `(self.pos, self.offset)`

+        """If ReadableRepresentations is true, return a human-readable

+        representation, e.g. 'dog(n.)'.

+        

+        If ReadableRepresentations is false, return a machine-readable

+        representation, e.g. "getSynset(pos, 1234)".

+        """

+        if ReadableRepresentations:

+            return str(self)

+        return "getSynset" + repr((self.pos, self.offset))

     def __cmp__(self, other):

-	return _compareInstances(self, other, ('pos', 'offset'))

+        return _compareInstances(self, other, ('pos', 'offset'))

     #

     # Sequence protocol (a Synset's elements are its senses).

     #

-    def __nonzero__(self):

-	return 1

+    def __bool__(self):

+        return 1

     def __len__(self):

-	"""

-	>>> len(N['dog'][0].synset)

-	3

-	"""

-	return len(self.getSenses())

+        """

+        >>> len(N['dog'][0].synset)

+        3

+        """

+        return len(self.getSenses())

     def __getitem__(self, idx):

-	"""

-	>>> N['dog'][0].synset[0] == N['dog'][0]

-	1

-	>>> N['dog'][0].synset['dog'] == N['dog'][0]

-	1

-	>>> N['dog'][0].synset[N['dog']] == N['dog'][0]

-	1

-	>>> N['cat'][6]

-	'cat' in {noun: big cat, cat}

-	"""

-	senses = self.getSenses()

-	if isinstance(idx, Word):

-	    idx = idx.form

-	if isinstance(idx, StringType):

-	    idx = _index(idx, map(lambda sense:sense.form, senses)) or \

-		  _index(idx, map(lambda sense:sense.form, senses), _equalsIgnoreCase)

-	return senses[idx]

+        """

+        >>> N['dog'][0].synset[0] == N['dog'][0]

+        1

+        >>> N['dog'][0].synset['dog'] == N['dog'][0]

+        1

+        >>> N['dog'][0].synset[N['dog']] == N['dog'][0]

+        1

+        >>> N['cat'][6]

+        'cat' in {noun: big cat, cat}

+        """

+        senses = self.getSenses()

+        if isinstance(idx, Word):

+            idx = idx.form

+        if isinstance(idx, str):

+            idx = _index(idx, [sense.form for sense in senses]) or \

+                  _index(idx, [sense.form for sense in senses], _equalsIgnoreCase)

+        return senses[idx]

     def __getslice__(self, i, j):

-	return self.getSenses()[i:j]

+        return self.getSenses()[i:j]

 class Sense:

@@ -527,7 +526,7 @@

           VERB_FRAME_STRINGS. These list the verb frames that this

           Sense partipates in.  Defined only for verbs.

-          >>> decide = V['decide'][0].synset	# first synset for 'decide'

+          >>> decide = V['decide'][0].synset        # first synset for 'decide'

           >>> decide[0].verbFrames

           (8, 2, 26, 29)

           >>> decide[1].verbFrames

@@ -538,124 +537,124 @@

     def __init__(sense, synset, senseTuple, verbFrames=None):

         "Initialize a sense from a synset's senseTuple."

-	# synset is stored by key (pos, synset) rather than object

-	# reference, to avoid creating a circular reference between

-	# Senses and Synsets that will prevent the vm from

-	# garbage-collecting them.

-	sense.pos = synset.pos

+        # synset is stored by key (pos, synset) rather than object

+        # reference, to avoid creating a circular reference between

+        # Senses and Synsets that will prevent the vm from

+        # garbage-collecting them.

+        sense.pos = synset.pos

         "part of speech -- one of NOUN, VERB, ADJECTIVE, ADVERB"

-	sense.synsetOffset = synset.offset

+        sense.synsetOffset = synset.offset

         "synset key.  This is used to retrieve the sense."

-	sense.verbFrames = verbFrames

+        sense.verbFrames = verbFrames

         """A sequence of integers that index into

         VERB_FRAME_STRINGS. These list the verb frames that this

         Sense partipates in.  Defined only for verbs."""

-	(form, idString) = senseTuple

-	sense.position = None

-	if '(' in form:

-	    index = string.index(form, '(')

-	    key = form[index + 1:-1]

-	    form = form[:index]

-	    if key == 'a':

-		sense.position = ATTRIBUTIVE

-	    elif key == 'p':

-		sense.position = PREDICATIVE

-	    elif key == 'ip':

-		sense.position = IMMEDIATE_POSTNOMINAL

-	    else:

-		raise "unknown attribute " + key

-	sense.form = string.replace(form, '_', ' ')

+        (form, idString) = senseTuple

+        sense.position = None

+        if '(' in form:

+            index = form.index('(')

+            key = form[index + 1:-1]

+            form = form[:index]

+            if key == 'a':

+                sense.position = ATTRIBUTIVE

+            elif key == 'p':

+                sense.position = PREDICATIVE

+            elif key == 'ip':

+                sense.position = IMMEDIATE_POSTNOMINAL

+            else:

+                raise "unknown attribute " + key

+        sense.form = form.replace('_', ' ')

         "orthographic representation of the Word this is a Sense of."

     def __getattr__(self, name):

-	# see the note at __init__ about why 'synset' is provided as a

-	# 'virtual' slot

-	if name == 'synset':

-	    return getSynset(self.pos, self.synsetOffset)

+        # see the note at __init__ about why 'synset' is provided as a

+        # 'virtual' slot

+        if name == 'synset':

+            return getSynset(self.pos, self.synsetOffset)

         elif name == 'lexname':

             return self.synset.lexname

-	else:

-	    raise AttributeError, name

+        else:

+            raise AttributeError(name)

     def __str__(self):

-	"""Return a human-readable representation.

-	

-	>>> str(N['dog'])

-	'dog(n.)'

-	"""

-	return `self.form` + " in " + str(self.synset)

+        """Return a human-readable representation.

+        

+        >>> str(N['dog'])

+        'dog(n.)'

+        """

+        return repr(self.form) + " in " + str(self.synset)

     def __repr__(self):

-	"""If ReadableRepresentations is true, return a human-readable

-	representation, e.g. 'dog(n.)'.

-	

-	If ReadableRepresentations is false, return a machine-readable

-	representation, e.g. "getWord('dog', 'noun')".

-	"""

-	if ReadableRepresentations:

-	    return str(self)

-	return "%s[%s]" % (`self.synset`, `self.form`)

+        """If ReadableRepresentations is true, return a human-readable

+        representation, e.g. 'dog(n.)'.

+        

+        If ReadableRepresentations is false, return a machine-readable

+        representation, e.g. "getWord('dog', 'noun')".

+        """

+        if ReadableRepresentations:

+            return str(self)

+        return "%s[%s]" % (repr(self.synset), repr(self.form))

     def getPointers(self, pointerType=None):

-	"""Return a sequence of Pointers.

-	

+        """Return a sequence of Pointers.

+        

         If pointerType is specified, only pointers of that type are

         returned.  In this case, pointerType should be an element of

         POINTER_TYPES.

-	

-	>>> N['dog'][0].getPointers()[:5]

-	(hypernym -> {noun: canine, canid}, member meronym -> {noun: Canis, genus Canis}, member meronym -> {noun: pack}, hyponym -> {noun: pooch, doggie, doggy, barker, bow-wow}, hyponym -> {noun: cur, mongrel, mutt})

-	>>> N['dog'][0].getPointers(HYPERNYM)

-	(hypernym -> {noun: canine, canid},)

-	"""

-	senseIndex = _index(self, self.synset.getSenses())

-	def pointsFromThisSense(pointer, selfIndex=senseIndex):

-	    return pointer.sourceIndex == 0 or pointer.sourceIndex - 1 == selfIndex

-	return filter(pointsFromThisSense, self.synset.getPointers(pointerType))

+        

+        >>> N['dog'][0].getPointers()[:5]

+        (hypernym -> {noun: canine, canid}, member meronym -> {noun: Canis, genus Canis}, member meronym -> {noun: pack}, hyponym -> {noun: pooch, doggie, doggy, barker, bow-wow}, hyponym -> {noun: cur, mongrel, mutt})

+        >>> N['dog'][0].getPointers(HYPERNYM)

+        (hypernym -> {noun: canine, canid},)

+        """

+        senseIndex = _index(self, self.synset.getSenses())

+        def pointsFromThisSense(pointer, selfIndex=senseIndex):

+            return pointer.sourceIndex == 0 or pointer.sourceIndex - 1 == selfIndex

+        return list(filter(pointsFromThisSense, self.synset.getPointers(pointerType)))

     pointers = getPointers # backwards compatability

     def getPointerTargets(self, pointerType=None):

-	"""Return a sequence of Senses or Synsets.

-	

+        """Return a sequence of Senses or Synsets.

+        

         If pointerType is specified, only targets of pointers of that

         type are returned.  In this case, pointerType should be an

         element of POINTER_TYPES.

-	

-	>>> N['dog'][0].getPointerTargets()[:5]

-	[{noun: canine, canid}, {noun: Canis, genus Canis}, {noun: pack}, {noun: pooch, doggie, doggy, barker, bow-wow}, {noun: cur, mongrel, mutt}]

-	>>> N['dog'][0].getPointerTargets(HYPERNYM)

-	[{noun: canine, canid}]

-	"""

-	return map(Pointer.target, self.getPointers(pointerType))

+        

+        >>> N['dog'][0].getPointerTargets()[:5]

+        [{noun: canine, canid}, {noun: Canis, genus Canis}, {noun: pack}, {noun: pooch, doggie, doggy, barker, bow-wow}, {noun: cur, mongrel, mutt}]

+        >>> N['dog'][0].getPointerTargets(HYPERNYM)

+        [{noun: canine, canid}]

+        """

+        return list(map(Pointer.target, self.getPointers(pointerType)))

     pointerTargets = getPointerTargets # backwards compatability

     def getSenses(self):

-	return self,

+        return self,

     senses = getSenses # backwards compatability

     def isTagged(self):

-	"""Return 1 if any sense is tagged.

-	

-	>>> N['dog'][0].isTagged()

-	1

-	>>> N['dog'][1].isTagged()

-	0

-	"""

-	word = self.word()

-	return _index(self, word.getSenses()) < word.taggedSenseCount

+        """Return 1 if any sense is tagged.

+        

+        >>> N['dog'][0].isTagged()