--- /dev/null
+"""Provides simple functions for common queries
+
+These include identifier- and name-based lookup, filtering out base forms
+of pokemon, ordering by name, and getting canonical "pokedex" lists (i.e.
+ordered and without cruft like alternate pokemon forms or Shadow moves)
+"""
+
+from sqlalchemy.orm import aliased
+
+from pokedex.db import tables
+
+### Getters
+
+def get(session, table, identifier=None, name=None, id=None,
+ form_identifier=None, form_name=None, language=None, is_pokemon=None):
+ """Get one object from the database.
+
+ session: The session to use (from pokedex.db.connect())
+ table: The table to select from (such as pokedex.db.tables.Move)
+
+ identifier: Identifier of the object
+ name: The name of the object
+ id: The ID number of the object
+ form_identifier: For pokemon, identifier of the form
+ form_name: For pokemon, name of the form
+
+ language: A Language to use for name and form_name
+ is_pokemon: If true, specifies that the table should be treated as a
+ pokemon table (handling forms specially). If None and table is the
+ (unaliased) Pokemon, it is set to True. Otherwise, the pokemon forms
+ aren't handled.
+
+ All conditions must match, so it's not a good idea to specify more than one
+ of identifier/name/id at once.
+
+ If zero or more than one objects matching the criteria are found, the
+ appropriate SQLAlchemy exception is raised.
+ Exception: for pokemon, selects the form base unless form_* is given.
+ """
+
+ if is_pokemon is None:
+ is_pokemon = (table is tables.Pokemon)
+
+ query = session.query(table)
+
+ if identifier is not None:
+ query = query.filter_by(identifier=identifier)
+
+ if name is not None:
+ query = filter_name(query, table, name, language)
+
+ if id is not None:
+ query = query.filter_by(id=id)
+
+ if form_identifier is not None or form_name is not None:
+ if is_pokemon:
+ query = query.join(table.unique_form)
+ if form_identifier is not None:
+ query = query.filter(tables.PokemonForm.identifier ==
+ form_identifier)
+ if form_name is not None:
+ query = filter_name(query, table, form_name, language)
+ else:
+ raise ValueError(
+ "form_identifier and form_name only make sense for pokemon")
+ elif is_pokemon:
+ query = filter_base_forms(query)
+
+ return query.one()
+
+### Helpers
+
+def filter_name(query, table, name, language):
+ """Filter a query by name, return the resulting query
+
+ query: The query to filter
+ table: The table of named objects
+ name: The name to look for. May be a tuple of alternatives.
+ language: The language for "name", or None for the session default
+ """
+ if language is None:
+ query = query.filter(table.name == name)
+ else:
+ names_table = table.names_table
+ query = query.join(names_table)
+ query = query.filter(names_table.foreign_id == table.id)
+ query = query.filter(names_table.local_language_id == language.id)
+ if isinstance(name, tuple):
+ query = query.filter(names_table.name in name)
+ else:
+ query = query.filter(names_table.name == name)
+ return query
+
+def filter_base_forms(query):
+ """Filter only base forms of pokemon, and return the resulting query
+ """
+ query = query.filter(tables.Pokemon.forms.any())
+ return query
+
+def order_by_name(query, table, language=None, *extra_languages):
+ """Order a query by name.
+
+ query: The query to order
+ table: Table of the named objects
+ language: The language to order names by. If None, use the
+ connection default.
+ extra_languages: Extra languages to order by, should the translations for
+ `language` be incomplete (or ambiguous).
+
+ Uses the identifier as a fallback ordering.
+ """
+ if language is None:
+ query = query.outerjoin(table.names_local)
+ query = query.order_by(table.names_table.name)
+ else:
+ extra_languages = (language, ) + extra_languages
+ for language in extra_languages:
+ names_table = aliased(table.names_table)
+ query = query.outerjoin(names_table)
+ query = query.filter(names_table.foreign_id == table.id)
+ query = query.filter(names_table.local_language_id == language.id)
+ query = query.order_by(names_table.name)
+ query = query.order_by(table.identifier)
+ return query
+
+_name = object()
+def get_all(session, table, order=_name):
+ """Shortcut to get an ordered query from table.
+
+ session: The session to use
+ table: The table to select from
+ order: A clause to order by, or None for no ordering.
+ The default is to order by name; this can also be specified explicitly
+ with the table's name property (e.g. tables.Pokemon.name). Be aware
+ that the query's order_by will not order by name this way.
+ """
+ query = session.query(table)
+ if order is table.name or order is _name:
+ query = order_by_name(query, table)
+ elif order is not None:
+ query = query.order_by(order)
+ return query
+
+### Shortcuts
+
+def pokemon(session, order=tables.Pokemon.id):
+ """Return a query for all base form pokemon, ordered by id by default
+
+ See get_all for the session and order arguments (but note the default for
+ pokemon is to order by id).
+ """
+ query = get_all(session, tables.Pokemon, order=order)
+ query = query.filter(tables.Pokemon.forms.any())
+ return query
+
+def moves(session, order=_name):
+ """Return a query for moves in the mainline games (i.e. no Shadow moves)
+
+ See get_all for the session and order arguments.
+ """
+ return get_all(session, tables.Move, order=order).filter(tables.Move.id < 10000)
+
+def types(session, order=_name):
+ """Return a query for sane types (i.e. not ???, Shadow)
+
+ See get_all for the session and order arguments.
+ """
+ return get_all(session, tables.Type, order=order).filter(tables.Type.id < 10000)
+
+def items(session, order=_name):
+ """Return a query for items
+
+ See get_all for the session and order arguments.
+ """
+ return get_all(session, tables.Item, order=order)
projects / zzz-pokedex.git / blobdiff