X-Git-Url: http://git.veekun.com/zzz-pokedex.git/blobdiff_plain/706d0f3ea899d26403b412545d60877996e81994..2ec82ef579f8ec72117cacf6e455da8ab8d961d5:/pokedex/lookup.py?ds=sidebyside diff --git a/pokedex/lookup.py b/pokedex/lookup.py index 115e9f0..bab2a42 100644 --- a/pokedex/lookup.py +++ b/pokedex/lookup.py @@ -1,7 +1,5 @@ # encoding: utf8 -from collections import namedtuple import os, os.path -import pkg_resources import random import re import shutil @@ -16,9 +14,12 @@ from whoosh.qparser import QueryParser import whoosh.scoring import whoosh.spelling +from pokedex.util import namedtuple + from pokedex.db import connect import pokedex.db.tables as tables from pokedex.roomaji import romanize +from pokedex.defaults import get_default_index_dir __all__ = ['PokedexLookup'] @@ -28,6 +29,24 @@ rx_is_number = re.compile('^\d+$') LookupResult = namedtuple('LookupResult', ['object', 'indexed_name', 'name', 'language', 'iso3166', 'exact']) +class UninitializedIndex(object): + class UninitializedIndexError(Exception): + pass + + def __nonzero__(self): + """Dummy object should identify itself as False.""" + return False + + def __bool__(self): + """Python 3000 version of the above. Future-proofing rules!""" + return False + + def __getattr__(self, *args, **kwargs): + raise self.UninitializedIndexError( + "The lookup index does not exist. Please use `pokedex setup` " + "or lookup.rebuild_index() to create it." + ) + class LanguageWeighting(whoosh.scoring.Weighting): """A scoring class that forces otherwise-equal English results to come before foreign results. @@ -67,7 +86,7 @@ class PokedexLookup(object): ) - def __init__(self, directory=None, session=None, recreate=False): + def __init__(self, directory=None, session=None): """Opens the whoosh index stored in the named directory. If the index doesn't already exist, it will be created. @@ -76,22 +95,19 @@ class PokedexLookup(object): `pokedex` egg directory. `session` - If the index needs to be created, this database session will be - used. Defaults to an attempt to connect to the default SQLite - database installed by `pokedex setup`. - - `recreate` - If set to True, the whoosh index will be created even if it already - exists. + Used for creating the index and retrieving objects. Defaults to an + attempt to connect to the default SQLite database installed by + `pokedex setup`. """ # By the time this returns, self.index, self.speller, and self.session # must be set - # Defaults - if not directory: - directory = pkg_resources.resource_filename('pokedex', - 'data/whoosh-index') + # If a directory was not given, use the default + if directory is None: + directory = get_default_index_dir() + + self.directory = directory if session: self.session = session @@ -99,31 +115,33 @@ class PokedexLookup(object): self.session = connect() # Attempt to open or create the index - directory_exists = os.path.exists(directory) - if directory_exists and not recreate: - # Already exists; should be an index! Bam, done. - try: - self.index = whoosh.index.open_dir(directory, indexname='MAIN') - spell_store = whoosh.filedb.filestore.FileStorage(directory) - self.speller = whoosh.spelling.SpellChecker(spell_store) - return - except whoosh.index.EmptyIndexError as e: - # Apparently not a real index. Fall out and create it - pass - - # Delete and start over if we're going to bail anyway. - if directory_exists and recreate: - # Be safe and only delete if it looks like a whoosh index, i.e., - # everything starts with _ - if all(f[0] == '_' for f in os.listdir(directory)): - shutil.rmtree(directory) - directory_exists = False - - if not directory_exists: - os.mkdir(directory) - - - ### Create index + if not os.path.exists(directory) or not os.listdir(directory): + # Directory doesn't exist OR is empty; caller needs to use + # rebuild_index before doing anything. Provide a dummy object that + # complains when used + self.index = UninitializedIndex() + self.speller = UninitializedIndex() + return + + # Otherwise, already exists; should be an index! Bam, done. + # Note that this will explode if the directory exists but doesn't + # contain an index; that's a feature + try: + self.index = whoosh.index.open_dir(directory, indexname='MAIN') + except whoosh.index.EmptyIndexError: + raise IOError( + "The index directory already contains files. " + "Please use a dedicated directory for the lookup index." + ) + + # Create speller, and done + spell_store = whoosh.filedb.filestore.FileStorage(directory) + self.speller = whoosh.spelling.SpellChecker(spell_store) + + + def rebuild_index(self): + """Creates the index from scratch.""" + schema = whoosh.fields.Schema( name=whoosh.fields.ID(stored=True), table=whoosh.fields.ID(stored=True), @@ -133,8 +151,11 @@ class PokedexLookup(object): display_name=whoosh.fields.STORED, # non-lowercased name ) - self.index = whoosh.index.create_in(directory, schema=schema, - indexname='MAIN') + if not os.path.exists(self.directory): + os.mkdir(self.directory) + + self.index = whoosh.index.create_in(self.directory, schema=schema, + indexname='MAIN') writer = self.index.writer() # Index every name in all our tables of interest @@ -290,15 +311,17 @@ class PokedexLookup(object): Returns None for a bogus name. """ + # Table object if hasattr(name, '__tablename__'): return getattr(name, '__tablename__') - elif name in self.indexed_tables: - return name - elif name + 's' in self.indexed_tables: - return name + 's' - else: - # Bogus. Be nice and return dummy - return None + + # Table name + for table in self.indexed_tables.values(): + if name in (table.__tablename__, table.__singlename__): + return table.__tablename__ + + # Bogus. Be nice and return dummy + return None def _whoosh_records_to_results(self, records, exact=True): """Converts a list of whoosh's indexed records to LookupResult tuples @@ -387,13 +410,20 @@ class PokedexLookup(object): # Do different things depending what the query looks like # Note: Term objects do an exact match, so we don't have to worry about # a query parser tripping on weird characters in the input + try: + # Let Python try to convert to a number, so 0xff works + name_as_number = int(name, base=0) + except ValueError: + # Oh well + name_as_number = None + if '*' in name or '?' in name: exact_only = True query = whoosh.query.Wildcard(u'name', name) - elif rx_is_number.match(name): + elif name_as_number is not None: # Don't spell-check numbers! exact_only = True - query = whoosh.query.Term(u'row_id', name) + query = whoosh.query.Term(u'row_id', unicode(name_as_number)) else: # Not an integer query = whoosh.query.Term(u'name', name)