rpms/mythes-en
7
0
Fork 0
Code Issues Pull Requests Releases Activity
ce224c3c3d
mythes-en/mythes-en.python3.patch
Petr Šabata 9b91c724ea RHEL 9.0.0 Alpha bootstrap 
The content of this branch was automatically imported from Fedora ELN
with the following as its source:
https://src.fedoraproject.org/rpms/mythes-en#70b965ae0e9074dc0c50658ad577f609e4b12706
2020-10-15 20:44:49 +02:00

1632 lines
53 KiB
Diff
Raw Blame History

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()
+ 1
+ >>> N['dog'][1].isTagged()
+ 0
+ """
+ word = self.word()
+ return _index(self, word.getSenses()) < word.taggedSenseCount
def getWord(self):
- return getWord(self.form, self.pos)
+ return getWord(self.form, self.pos)
word = getWord # backwards compatability
def __cmp__(self, other):
- def senseIndex(sense, synset=self.synset):
- return _index(sense, synset.getSenses(), testfn=lambda a,b: a.form == b.form)
- return _compareInstances(self, other, ('synset',)) or cmp(senseIndex(self), senseIndex(other))
+ def senseIndex(sense, synset=self.synset):
+ return _index(sense, synset.getSenses(), testfn=lambda a,b: a.form == b.form)
+ return _compareInstances(self, other, ('synset',)) or cmp(senseIndex(self), senseIndex(other))
class Pointer:
@@ -670,21 +669,21 @@
"""
_POINTER_TYPE_TABLE = {
- '!': ANTONYM,
+ '!': ANTONYM,
'@': HYPERNYM,
'~': HYPONYM,
- '=': ATTRIBUTE,
+ '=': ATTRIBUTE,
'^': ALSO_SEE,
'*': ENTAILMENT,
'>': CAUSE,
- '$': VERB_GROUP,
- '#m': MEMBER_MERONYM,
+ '$': VERB_GROUP,
+ '#m': MEMBER_MERONYM,
'#s': SUBSTANCE_MERONYM,
'#p': PART_MERONYM,
- '%m': MEMBER_HOLONYM,
+ '%m': MEMBER_HOLONYM,
'%s': SUBSTANCE_HOLONYM,
'%p': PART_HOLONYM,
- '&': SIMILAR,
+ '&': SIMILAR,
'<': PARTICIPLE_OF,
'\\': PERTAINYM,
# New in wn 2.0:
@@ -698,57 +697,57 @@
}
def __init__(self, sourceOffset, pointerTuple):
- (type, offset, pos, indices) = pointerTuple
- # dnaber: try to adapt to WordNet 2.1:
- if type == "@i":
- type = "@"
- if type == "~i":
- type = "~"
- # /dnaber
- self.type = Pointer._POINTER_TYPE_TABLE[type]
+ (type, offset, pos, indices) = pointerTuple
+ # dnaber: try to adapt to WordNet 2.1:
+ if type == "@i":
+ type = "@"
+ if type == "~i":
+ type = "~"
+ # /dnaber
+ self.type = Pointer._POINTER_TYPE_TABLE[type]
"""One of POINTER_TYPES."""
- self.sourceOffset = sourceOffset
- self.targetOffset = int(offset)
- self.pos = _normalizePOS(pos)
+ self.sourceOffset = sourceOffset
+ self.targetOffset = int(offset)
+ self.pos = _normalizePOS(pos)
"""part of speech -- one of NOUN, VERB, ADJECTIVE, ADVERB"""
- indices = string.atoi(indices, 16)
- self.sourceIndex = indices >> 8
- self.targetIndex = indices & 255
+ indices = int(indices, 16)
+ self.sourceIndex = indices >> 8
+ self.targetIndex = indices & 255
def getSource(self):
- synset = getSynset(self.pos, self.sourceOffset)
- if self.sourceIndex:
- return synset[self.sourceIndex - 1]
- else:
- return synset
+ synset = getSynset(self.pos, self.sourceOffset)
+ if self.sourceIndex:
+ return synset[self.sourceIndex - 1]
+ else:
+ return synset
source = getSource # backwards compatability
def getTarget(self):
- synset = getSynset(self.pos, self.targetOffset)
- if self.targetIndex:
- return synset[self.targetIndex - 1]
- else:
- return synset
+ synset = getSynset(self.pos, self.targetOffset)
+ if self.targetIndex:
+ return synset[self.targetIndex - 1]
+ else:
+ return synset
target = getTarget # backwards compatability
def __str__(self):
- return self.type + " -> " + str(self.target())
+ return self.type + " -> " + str(self.target())
def __repr__(self):
- if ReadableRepresentations:
- return str(self)
- return "<" + str(self) + ">"
+ if ReadableRepresentations:
+ return str(self)
+ return "<" + str(self) + ">"
def __cmp__(self, other):
- diff = _compareInstances(self, other, ('pos', 'sourceOffset'))
- if diff:
- return diff
- synset = self.source()
- def pointerIndex(sense, synset=synset):
- return _index(sense, synset.getPointers(), testfn=lambda a,b: not _compareInstances(a, b, ('type', 'sourceIndex', 'targetIndex')))
- return cmp(pointerIndex(self), pointerIndex(other))
+ diff = _compareInstances(self, other, ('pos', 'sourceOffset'))
+ if diff:
+ return diff
+ synset = self.source()
+ def pointerIndex(sense, synset=synset):
+ return _index(sense, synset.getPointers(), testfn=lambda a,b: not _compareInstances(a, b, ('type', 'sourceIndex', 'targetIndex')))
+ return cmp(pointerIndex(self), pointerIndex(other))
# Loading the lexnames
@@ -769,7 +768,7 @@
def setupLexnames():
for l in open(WNSEARCHDIR+'/lexnames').readlines():
- i,name,category = string.split(l)
+ i,name,category = l.split()
Lexname(name,PartsOfSpeech[int(category)-1])
setupLexnames()
@@ -802,59 +801,59 @@
"""
def __init__(self, pos, filenameroot):
- self.pos = pos
+ self.pos = pos
"""part of speech -- one of NOUN, VERB, ADJECTIVE, ADVERB"""
- self.indexFile = _IndexFile(pos, filenameroot)
- self.dataFile = open(_dataFilePathname(filenameroot), _FILE_OPEN_MODE)
+ self.indexFile = _IndexFile(pos, filenameroot)
+ self.dataFile = open(_dataFilePathname(filenameroot), _FILE_OPEN_MODE)
def __repr__(self):
- dictionaryVariables = {N: 'N', V: 'V', ADJ: 'ADJ', ADV: 'ADV'}
- if dictionaryVariables.get(self):
- return self.__module__ + "." + dictionaryVariables[self]
- return "<%s.%s instance for %s>" % (self.__module__, "Dictionary", self.pos)
+ dictionaryVariables = {N: 'N', V: 'V', ADJ: 'ADJ', ADV: 'ADV'}
+ if dictionaryVariables.get(self):
+ return self.__module__ + "." + dictionaryVariables[self]
+ return "<%s.%s instance for %s>" % (self.__module__, "Dictionary", self.pos)
def getWord(self, form, line=None):
- key = string.replace(string.lower(form), ' ', '_')
- pos = self.pos
- def loader(key=key, line=line, indexFile=self.indexFile):
- line = line or indexFile.get(key)
- return line and Word(line)
- word = _entityCache.get((pos, key), loader)
- if word:
- return word
- else:
- raise KeyError, "%s is not in the %s database" % (`form`, `pos`)
+ key = form.lower().replace(' ', '_')
+ pos = self.pos
+ def loader(key=key, line=line, indexFile=self.indexFile):
+ line = line or indexFile.get(key)
+ return line and Word(line)
+ word = _entityCache.get((pos, key), loader)
+ if word != None:
+ return word
+ else:
+ raise KeyError("%s is not in the %s database" % (repr(form), repr(pos)))
def getSynset(self, offset):
- pos = self.pos
- def loader(pos=pos, offset=offset, dataFile=self.dataFile):
- return Synset(pos, offset, _lineAt(dataFile, offset))
- return _entityCache.get((pos, offset), loader)
+ pos = self.pos
+ def loader(pos=pos, offset=offset, dataFile=self.dataFile):
+ return Synset(pos, offset, _lineAt(dataFile, offset))
+ return _entityCache.get((pos, offset), loader)
def _buildIndexCacheFile(self):
- self.indexFile._buildIndexCacheFile()
+ self.indexFile._buildIndexCacheFile()
#
# Sequence protocol (a Dictionary's items are its Words)
#
- def __nonzero__(self):
- """Return false. (This is to avoid scanning the whole index file
- to compute len when a Dictionary is used in test position.)
-
- >>> N and 'true'
- 'true'
- """
- return 1
+ def __bool__(self):
+ """Return false. (This is to avoid scanning the whole index file
+ to compute len when a Dictionary is used in test position.)
+
+ >>> N and 'true'
+ 'true'
+ """
+ return 1
def __len__(self):
- """Return the number of index entries.
-
- >>> len(ADJ)
- 21435
- """
- if not hasattr(self, 'length'):
- self.length = len(self.indexFile)
- return self.length
+ """Return the number of index entries.
+
+ >>> len(ADJ)
+ 21435
+ """
+ if not hasattr(self, 'length'):
+ self.length = len(self.indexFile)
+ return self.length
def __getslice__(self, a, b):
results = []
@@ -868,22 +867,22 @@
return results
def __getitem__(self, index):
- """If index is a String, return the Word whose form is
- index. If index is an integer n, return the Word
- indexed by the n'th Word in the Index file.
-
- >>> N['dog']
- dog(n.)
- >>> N[0]
- 'hood(n.)
- """
- if isinstance(index, StringType):
- return self.getWord(index)
- elif isinstance(index, IntType):
- line = self.indexFile[index]
- return self.getWord(string.replace(line[:string.find(line, ' ')], '_', ' '), line)
- else:
- raise TypeError, "%s is not a String or Int" % `index`
+ """If index is a String, return the Word whose form is
+ index. If index is an integer n, return the Word
+ indexed by the n'th Word in the Index file.
+
+ >>> N['dog']
+ dog(n.)
+ >>> N[0]
+ 'hood(n.)
+ """
+ if isinstance(index, str):
+ return self.getWord(index)
+ elif isinstance(index, int):
+ line = self.indexFile[index]
+ return self.getWord(string.replace(line[:string.find(line, ' ')], '_', ' '), line)
+ else:
+ raise TypeError("%s is not a String or Int" % repr(index))
#
# Dictionary protocol
@@ -892,54 +891,54 @@
#
def get(self, key, default=None):
- """Return the Word whose form is _key_, or _default_.
-
- >>> N.get('dog')
- dog(n.)
- >>> N.get('inu')
- """
- try:
- return self[key]
- except LookupError:
- return default
+ """Return the Word whose form is _key_, or _default_.
+
+ >>> N.get('dog')
+ dog(n.)
+ >>> N.get('inu')
+ """
+ try:
+ return self[key]
+ except LookupError:
+ return default
def keys(self):
- """Return a sorted list of strings that index words in this
- dictionary."""
- return self.indexFile.keys()
+ """Return a sorted list of strings that index words in this
+ dictionary."""
+ return list(self.indexFile.keys())
def has_key(self, form):
- """Return true iff the argument indexes a word in this dictionary.
-
- >>> N.has_key('dog')
- 1
- >>> N.has_key('inu')
- 0
- """
- return self.indexFile.has_key(form)
+ """Return true iff the argument indexes a word in this dictionary.
+
+ >>> N.has_key('dog')
+ 1
+ >>> N.has_key('inu')
+ 0
+ """
+ return form in self.indexFile
#
# Testing
#
def _testKeys(self):
- """Verify that index lookup can find each word in the index file."""
- print "Testing: ", self
- file = open(self.indexFile.file.name, _FILE_OPEN_MODE)
- counter = 0
- while 1:
- line = file.readline()
- if line == '': break
- if line[0] != ' ':
- key = string.replace(line[:string.find(line, ' ')], '_', ' ')
- if (counter % 1000) == 0:
- print "%s..." % (key,),
- import sys
- sys.stdout.flush()
- counter = counter + 1
- self[key]
- file.close()
- print "done."
+ """Verify that index lookup can find each word in the index file."""
+ print("Testing: ", self)
+ file = open(self.indexFile.file.name, _FILE_OPEN_MODE)
+ counter = 0
+ while 1:
+ line = file.readline()
+ if line == '': break
+ if line[0] != ' ':
+ key = string.replace(line[:string.find(line, ' ')], '_', ' ')
+ if (counter % 1000) == 0:
+ print("%s..." % (key,), end=' ')
+ import sys
+ sys.stdout.flush()
+ counter = counter + 1
+ self[key]
+ file.close()
+ print("done.")
class _IndexFile:
@@ -947,69 +946,69 @@
Sequence and Dictionary interface to a sorted index file."""
def __init__(self, pos, filenameroot):
- self.pos = pos
- self.file = open(_indexFilePathname(filenameroot), _FILE_OPEN_MODE)
- self.offsetLineCache = {} # Table of (pathname, offset) -> (line, nextOffset)
- self.rewind()
- self.shelfname = os.path.join(WNSEARCHDIR, pos + ".pyidx")
- try:
- import shelve
- self.indexCache = shelve.open(self.shelfname, 'r')
- except:
- pass
+ self.pos = pos
+ self.file = open(_indexFilePathname(filenameroot), _FILE_OPEN_MODE)
+ self.offsetLineCache = {} # Table of (pathname, offset) -> (line, nextOffset)
+ self.rewind()
+ self.shelfname = os.path.join(WNSEARCHDIR, pos + ".pyidx")
+ try:
+ import shelve
+ self.indexCache = shelve.open(self.shelfname, 'r')
+ except:
+ pass
def rewind(self):
- self.file.seek(0)
- while 1:
- offset = self.file.tell()
- line = self.file.readline()
- if (line[0] != ' '):
- break
- self.nextIndex = 0
- self.nextOffset = offset
+ self.file.seek(0)
+ while 1:
+ offset = self.file.tell()
+ line = self.file.readline()
+ if (line[0] != ' '):
+ break
+ self.nextIndex = 0
+ self.nextOffset = offset
#
# Sequence protocol (an _IndexFile's items are its lines)
#
- def __nonzero__(self):
- return 1
+ def __bool__(self):
+ return 1
def __len__(self):
- if hasattr(self, 'indexCache'):
- return len(self.indexCache)
- self.rewind()
- lines = 0
- while 1:
- line = self.file.readline()
- if line == "":
- break
- lines = lines + 1
- return lines
+ if hasattr(self, 'indexCache'):
+ return len(self.indexCache)
+ self.rewind()
+ lines = 0
+ while 1:
+ line = self.file.readline()
+ if line == "":
+ break
+ lines = lines + 1
+ return lines
- def __nonzero__(self):
- return 1
+ def __bool__(self):
+ return 1
def __getitem__(self, index):
- if isinstance(index, StringType):
- if hasattr(self, 'indexCache'):
- return self.indexCache[index]
- return binarySearchFile(self.file, index, self.offsetLineCache, 8)
- elif isinstance(index, IntType):
- if hasattr(self, 'indexCache'):
- return self.get(self.keys[index])
- if index < self.nextIndex:
- self.rewind()
- while self.nextIndex <= index:
- self.file.seek(self.nextOffset)
- line = self.file.readline()
- if line == "":
- raise IndexError, "index out of range"
- self.nextIndex = self.nextIndex + 1
- self.nextOffset = self.file.tell()
- return line
- else:
- raise TypeError, "%s is not a String or Int" % `index`
-
+ if isinstance(index, str):
+ if hasattr(self, 'indexCache'):
+ return self.indexCache[index]
+ return binarySearchFile(self.file, index, self.offsetLineCache, 8)
+ elif isinstance(index, int):
+ if hasattr(self, 'indexCache'):
+ return self.get(self.keys[index])
+ if index < self.nextIndex:
+ self.rewind()
+ while self.nextIndex <= index:
+ self.file.seek(self.nextOffset)
+ line = self.file.readline()
+ if line == "":
+ raise IndexError("index out of range")
+ self.nextIndex = self.nextIndex + 1
+ self.nextOffset = self.file.tell()
+ return line
+ else:
+ raise TypeError("%s is not a String or Int" % repr(index))
+
#
# Dictionary protocol
#
@@ -1017,62 +1016,62 @@
#
def get(self, key, default=None):
- try:
- return self[key]
- except LookupError:
- return default
+ try:
+ return self[key]
+ except LookupError:
+ return default
def keys(self):
- if hasattr(self, 'indexCache'):
- keys = self.indexCache.keys()
- keys.sort()
- return keys
- else:
- keys = []
- self.rewind()
- while 1:
- line = self.file.readline()
- if not line: break
+ if hasattr(self, 'indexCache'):
+ keys = list(self.indexCache.keys())
+ keys.sort()
+ return keys
+ else:
+ keys = []
+ self.rewind()
+ while 1:
+ line = self.file.readline()
+ if not line: break
key = line.split(' ', 1)[0]
- keys.append(key.replace('_', ' '))
- return keys
+ keys.append(key.replace('_', ' '))
+ return keys
def has_key(self, key):
- key = key.replace(' ', '_') # test case: V['haze over']
- if hasattr(self, 'indexCache'):
- return self.indexCache.has_key(key)
- return self.get(key) != None
+ key = key.replace(' ', '_') # test case: V['haze over']
+ if hasattr(self, 'indexCache'):
+ return key in self.indexCache
+ return self.get(key) != None
#
# Index file
#
def _buildIndexCacheFile(self):
- import shelve
- import os
- print "Building %s:" % (self.shelfname,),
- tempname = self.shelfname + ".temp"
- try:
- indexCache = shelve.open(tempname)
- self.rewind()
- count = 0
- while 1:
- offset, line = self.file.tell(), self.file.readline()
- if not line: break
- key = line[:string.find(line, ' ')]
- if (count % 1000) == 0:
- print "%s..." % (key,),
- import sys
- sys.stdout.flush()
- indexCache[key] = line
- count = count + 1
- indexCache.close()
- os.rename(tempname, self.shelfname)
- finally:
- try: os.remove(tempname)
- except: pass
- print "done."
- self.indexCache = shelve.open(self.shelfname, 'r')
+ import shelve
+ import os
+ print("Building %s:" % (self.shelfname,), end=' ')
+ tempname = self.shelfname + ".temp"
+ try:
+ indexCache = shelve.open(tempname)
+ self.rewind()
+ count = 0
+ while 1:
+ offset, line = self.file.tell(), self.file.readline()
+ if not line: break
+ key = line[:string.find(line, ' ')]
+ if (count % 1000) == 0:
+ print("%s..." % (key,), end=' ')
+ import sys
+ sys.stdout.flush()
+ indexCache[key] = line
+ count = count + 1
+ indexCache.close()
+ os.rename(tempname, self.shelfname)
+ finally:
+ try: os.remove(tempname)
+ except: pass
+ print("done.")
+ self.indexCache = shelve.open(self.shelfname, 'r')
#
@@ -1099,20 +1098,20 @@
def _requirePointerType(pointerType):
if pointerType not in POINTER_TYPES:
- raise TypeError, `pointerType` + " is not a pointer type"
+ raise TypeError(repr(pointerType) + " is not a pointer type")
return pointerType
def _compareInstances(a, b, fields):
""""Return -1, 0, or 1 according to a comparison first by type,
then by class, and finally by each of fields.""" # " <- for emacs
if not hasattr(b, '__class__'):
- return cmp(type(a), type(b))
+ return cmp(type(a), type(b))
elif a.__class__ != b.__class__:
- return cmp(a.__class__, b.__class__)
+ return cmp(a.__class__, b.__class__)
for field in fields:
- diff = cmp(getattr(a, field), getattr(b, field))
- if diff:
- return diff
+ diff = cmp(getattr(a, field), getattr(b, field))
+ if diff:
+ return diff
return 0
def _equalsIgnoreCase(a, b):
@@ -1123,21 +1122,21 @@
>>> _equalsIgnoreCase('dOg', 'DOG')
1
"""
- return a == b or string.lower(a) == string.lower(b)
+ return a == b or a.lower() == b.lower()
#
# File utilities
#
def _dataFilePathname(filenameroot):
if os.name in ('dos', 'nt'):
- path = os.path.join(WNSEARCHDIR, filenameroot + ".dat")
+ path = os.path.join(WNSEARCHDIR, filenameroot + ".dat")
if os.path.exists(path):
return path
return os.path.join(WNSEARCHDIR, "data." + filenameroot)
def _indexFilePathname(filenameroot):
if os.name in ('dos', 'nt'):
- path = os.path.join(WNSEARCHDIR, filenameroot + ".idx")
+ path = os.path.join(WNSEARCHDIR, filenameroot + ".idx")
if os.path.exists(path):
return path
return os.path.join(WNSEARCHDIR, "index." + filenameroot)
@@ -1154,30 +1153,30 @@
#if count > 20:
# raise "infinite loop"
lastState = start, end
- middle = (start + end) / 2
- if cache.get(middle):
- offset, line = cache[middle]
- else:
- file.seek(max(0, middle - 1))
- if middle > 0:
- file.readline()
- offset, line = file.tell(), file.readline()
- if currentDepth < cacheDepth:
- cache[middle] = (offset, line)
+ middle = (start + end) / 2
+ if cache.get(middle):
+ offset, line = cache[middle]
+ else:
+ file.seek(max(0, middle - 1))
+ if middle > 0:
+ file.readline()
+ offset, line = file.tell(), file.readline()
+ if currentDepth < cacheDepth:
+ cache[middle] = (offset, line)
#print start, middle, end, offset, line,
- if offset > end:
- assert end != middle - 1, "infinite loop"
- end = middle - 1
- elif line[:keylen] == key:# and line[keylen + 1] == ' ':
- return line
+ if offset > end:
+ assert end != middle - 1, "infinite loop"
+ end = middle - 1
+ elif line[:keylen] == key:# and line[keylen + 1] == ' ':
+ return line
#elif offset == end:
# return None
- elif line > key:
- assert end != middle - 1, "infinite loop"
- end = middle - 1
- elif line < key:
- start = offset + len(line) - 1
- currentDepth = currentDepth + 1
+ elif line > key:
+ assert end != middle - 1, "infinite loop"
+ end = middle - 1
+ elif line < key:
+ start = offset + len(line) - 1
+ currentDepth = currentDepth + 1
thisState = start, end
if lastState == thisState:
# detects the condition where we're searching past the end
@@ -1206,12 +1205,12 @@
"""
index = 0
for element in sequence:
- value = element
- if keyfn:
- value = keyfn(value)
- if (not testfn and value == key) or (testfn and testfn(value, key)):
- return index
- index = index + 1
+ value = element
+ if keyfn:
+ value = keyfn(value)
+ if (not testfn and value == key) or (testfn and testfn(value, key)):
+ return index
+ index = index + 1
return None
def _partition(sequence, size, count):
@@ -1224,7 +1223,7 @@
partitions = []
for index in range(0, size * count, size):
- partitions.append(sequence[index:index + size])
+ partitions.append(sequence[index:index + size])
return (partitions, sequence[size * count:])
@@ -1269,49 +1268,49 @@
but the two implementations aren't directly comparable."""
def __init__(this, capacity):
- this.capacity = capacity
- this.clear()
+ this.capacity = capacity
+ this.clear()
def clear(this):
- this.values = {}
- this.history = {}
- this.oldestTimestamp = 0
- this.nextTimestamp = 1
+ this.values = {}
+ this.history = {}
+ this.oldestTimestamp = 0
+ this.nextTimestamp = 1
def removeOldestEntry(this):
- while this.oldestTimestamp < this.nextTimestamp:
- if this.history.get(this.oldestTimestamp):
- key = this.history[this.oldestTimestamp]
- del this.history[this.oldestTimestamp]
- del this.values[key]
- return
- this.oldestTimestamp = this.oldestTimestamp + 1
+ while this.oldestTimestamp < this.nextTimestamp:
+ if this.history.get(this.oldestTimestamp):
+ key = this.history[this.oldestTimestamp]
+ del this.history[this.oldestTimestamp]
+ del this.values[key]
+ return
+ this.oldestTimestamp = this.oldestTimestamp + 1
def setCapacity(this, capacity):
- if capacity == 0:
- this.clear()
- else:
- this.capacity = capacity
- while len(this.values) > this.capacity:
- this.removeOldestEntry()
+ if capacity == 0:
+ this.clear()
+ else:
+ this.capacity = capacity
+ while len(this.values) > this.capacity:
+ this.removeOldestEntry()
def get(this, key, loadfn=None):
- value = None
- if this.values:
- pair = this.values.get(key)
- if pair:
- (value, timestamp) = pair
- del this.history[timestamp]
- if value == None:
- value = loadfn and loadfn()
- if this.values != None:
- timestamp = this.nextTimestamp
- this.nextTimestamp = this.nextTimestamp + 1
- this.values[key] = (value, timestamp)
- this.history[timestamp] = key
- if len(this.values) > this.capacity:
- this.removeOldestEntry()
- return value
+ value = None
+ if this.values:
+ pair = this.values.get(key)
+ if pair:
+ (value, timestamp) = pair
+ del this.history[timestamp]
+ if value == None:
+ value = loadfn and loadfn()
+ if this.values != None:
+ timestamp = this.nextTimestamp
+ this.nextTimestamp = this.nextTimestamp + 1
+ this.values[key] = (value, timestamp)
+ this.history[timestamp] = key
+ if len(this.values) > this.capacity:
+ this.removeOldestEntry()
+ return value
class _NullCache:
@@ -1319,10 +1318,10 @@
LRUCache implements), but doesn't store any values."""
def clear():
- pass
+ pass
def get(this, key, loadfn=None):
- return loadfn and loadfn()
+ return loadfn and loadfn()
DEFAULT_CACHE_CAPACITY = 1000
@@ -1335,7 +1334,7 @@
def enableCache():
"""Enable the entity cache."""
if not isinstance(_entityCache, LRUCache):
- _entityCache = _LRUCache(size)
+ _entityCache = _LRUCache(size)
def clearCache():
"""Clear the entity cache."""
@@ -1373,36 +1372,36 @@
_POSNormalizationTable = {}
_POStoDictionaryTable = {}
for pos, abbreviations in (
- (NOUN, "noun n n."),
- (VERB, "verb v v."),
- (ADJECTIVE, "adjective adj adj. a s"),
- (ADVERB, "adverb adv adv. r")):
- tokens = string.split(abbreviations)
- for token in tokens:
- _POSNormalizationTable[token] = pos
- _POSNormalizationTable[string.upper(token)] = pos
+ (NOUN, "noun n n."),
+ (VERB, "verb v v."),
+ (ADJECTIVE, "adjective adj adj. a s"),
+ (ADVERB, "adverb adv adv. r")):
+ tokens = abbreviations.split()
+ for token in tokens:
+ _POSNormalizationTable[token] = pos
+ _POSNormalizationTable[token.upper()] = pos
for dict in Dictionaries:
- _POSNormalizationTable[dict] = dict.pos
- _POStoDictionaryTable[dict.pos] = dict
+ _POSNormalizationTable[dict] = dict.pos
+ _POStoDictionaryTable[dict.pos] = dict
_initializePOSTables()
def _normalizePOS(pos):
norm = _POSNormalizationTable.get(pos)
if norm:
- return norm
- raise TypeError, `pos` + " is not a part of speech type"
+ return norm
+ raise TypeError(repr(pos) + " is not a part of speech type")
def _dictionaryFor(pos):
pos = _normalizePOS(pos)
dict = _POStoDictionaryTable.get(pos)
if dict == None:
- raise RuntimeError, "The " + `pos` + " dictionary has not been created"
+ raise RuntimeError("The " + repr(pos) + " dictionary has not been created")
return dict
def buildIndexFiles():
for dict in Dictionaries:
- dict._buildIndexCacheFile()
+ dict._buildIndexCacheFile()
#
@@ -1412,7 +1411,7 @@
def _testKeys():
#This is slow, so don't do it as part of the normal test procedure.
for dictionary in Dictionaries:
- dictionary._testKeys()
+ dictionary._testKeys()
def _test(reset=0):
import doctest, wordnet
Reference in New Issue View Git Blame Copy Permalink