rpms/mythes-en
7
0
Fork 0
Code Issues Pull Requests Releases Activity
62064f0f9f
mythes-en/mythes-en.python3.patch

1632 lines
53 KiB
Diff
Raw Normal View History

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 18:44:49 +00:00
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 Copy Permalink