Multi-language markdown move properties

[zzz-pokedex.git] / pokedex / db / tables.py
diff --git a/pokedex/db/tables.py b/pokedex/db/tables.py

index e01f43d..cf9b780 100644 (file)
--- a/pokedex/db/tables.py
+++ b/pokedex/db/tables.py
@@ -15,162 +15,212 @@ Columns have a info dictionary with these keys:
    - identifier: A fan-made identifier in the [-_a-z0-9]* format. Not intended
      for translation.
    - latex: A formula in LaTeX syntax.
    - identifier: A fan-made identifier in the [-_a-z0-9]* format. Not intended
      for translation.
    - latex: A formula in LaTeX syntax.
-- foreign: If set, the column contains foreign (non-English) text.
-
  """
  # XXX: Check if "gametext" is set correctly everywhere
  
  """
  # XXX: Check if "gametext" is set correctly everywhere
  
-# XXX: Some columns paradoxically have official=True and markup='identifier'.
-# This is when one column is used as both the English name (lowercased) and
-# an identifier. This should be fixed.
-
  from sqlalchemy import Column, ForeignKey, MetaData, PrimaryKeyConstraint, Table
  from sqlalchemy import Column, ForeignKey, MetaData, PrimaryKeyConstraint, Table
-from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.ext.declarative import declarative_base, declared_attr
  from sqlalchemy.ext.associationproxy import association_proxy
  from sqlalchemy.ext.associationproxy import association_proxy
-from sqlalchemy.orm import backref, eagerload_all, relation
+from sqlalchemy.orm import backref, eagerload_all, relation, class_mapper
  from sqlalchemy.orm.session import Session
  from sqlalchemy.orm.session import Session
+from sqlalchemy.orm.collections import attribute_mapped_collection
  from sqlalchemy.sql import and_
  from sqlalchemy.types import *
  from sqlalchemy.sql import and_
  from sqlalchemy.types import *
+from inspect import isclass
  
  from pokedex.db import markdown
  
  metadata = MetaData()
  TableBase = declarative_base(metadata=metadata)
  
  
  from pokedex.db import markdown
  
  metadata = MetaData()
  TableBase = declarative_base(metadata=metadata)
  
-class Ability(TableBase):
-    """An ability a pokémon can have, such as Static or Pressure.
+### Helper classes
+class Named(object):
+    """Mixin for objects that have names"""
+    def __unicode__(self):
+        try:
+            return '<%s: %s>' % (type(self).__name__, self.identifier)
+        except AttributeError:
+            return '<%s>' % type(self).__name__
+
+    def __str__(self):
+        return unicode(self).encode('utf-8')
+
+    def __repr__(self):
+        return str(self)
+
+class OfficiallyNamed(Named):
+    """Mixin for stuff with official names"""
+
+class UnofficiallyNamed(Named):
+    """Mixin for stuff with unofficial names"""
+
+class LanguageSpecific(object):
+    """Mixin for prose and text tables"""
+    @declared_attr
+    def language_id(cls):
+        return Column(Integer, ForeignKey('languages.id'), primary_key=True, nullable=False,
+            info=dict(description="The language"))
+
+class LanguageSpecificColumn(object):
+    """A column that will not appear in the table it's defined in, but in a related one"""
+    def __init__(self, *args, **kwargs):
+        self.args = args
+        self.plural = kwargs.pop('plural')
+        self.kwargs = kwargs
+
+    def makeSAColumn(self):
+        return Column(*self.args, **self.kwargs)
+
+class ProseColumn(LanguageSpecificColumn):
+    """A column that will appear in the corresponding _prose table"""
+
+class TextColumn(LanguageSpecificColumn):
+    """A column that will appear in the corresponding _text table"""
+
+
+### The actual tables
+
+class Ability(TableBase, OfficiallyNamed):
+    u"""An ability a Pokémon can have, such as Static or Pressure.
      """
      __tablename__ = 'abilities'
      __singlename__ = 'ability'
      id = Column(Integer, primary_key=True, nullable=False,
      """
      __tablename__ = 'abilities'
      __singlename__ = 'ability'
      id = Column(Integer, primary_key=True, nullable=False,
-        info=dict(description="A numeric ID"))
-    name = Column(Unicode(24), nullable=False,
-        info=dict(description="The official English name of this ability", official=True, format='plaintext'))
+        info=dict(description="This ability's unique ID; matches the games' internal ID"))
+    identifier = Column(Unicode(24), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
      generation_id = Column(Integer, ForeignKey('generations.id'), nullable=False,
      generation_id = Column(Integer, ForeignKey('generations.id'), nullable=False,
-        info=dict(description="ID of the generation this ability was introduced in", detail=True))
-    effect = Column(markdown.MarkdownColumn(5120), nullable=False,
-        info=dict(description="Detailed description of this ability's effect", format='markdown'))
-    short_effect = Column(markdown.MarkdownColumn(255), nullable=False,
-        info=dict(description="Short summary of this ability's effect", format='markdown'))
-
-class AbilityFlavorText(TableBase):
-    """In-game flavor text of an ability
+        info=dict(description="The ID of the generation this ability was introduced in", detail=True))
+    effect = ProseColumn(markdown.MarkdownColumn(5120), plural='effects', nullable=False,
+        info=dict(description="A detailed description of this ability's effect", format='markdown'))
+    short_effect = ProseColumn(markdown.MarkdownColumn(255), plural='short_effects', nullable=False,
+        info=dict(description="A short summary of this ability's effect", format='markdown'))
+
+class AbilityChangelog(TableBase):
+    """History of changes to abilities across main game versions."""
+    __tablename__ = 'ability_changelog'
+    __singlename__ = 'ability_changelog'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description="This change's unique ID"))
+    ability_id = Column(Integer, ForeignKey('abilities.id'), nullable=False,
+        info=dict(description="The ID of the ability that changed"))
+    changed_in_version_group_id = Column(Integer, ForeignKey('version_groups.id'), nullable=False,
+        info=dict(description="The ID of the version group in which the ability changed"))
+    effect = ProseColumn(markdown.MarkdownColumn(255), plural='effects', nullable=False,
+        info=dict(description="A description of the old behavior", format='markdown'))
+
+class AbilityFlavorText(TableBase, LanguageSpecific):
+    u"""In-game flavor text of an ability
      """
      __tablename__ = 'ability_flavor_text'
      ability_id = Column(Integer, ForeignKey('abilities.id'), primary_key=True, nullable=False, autoincrement=False,
      """
      __tablename__ = 'ability_flavor_text'
      ability_id = Column(Integer, ForeignKey('abilities.id'), primary_key=True, nullable=False, autoincrement=False,
-        info=dict(description="A numeric ID"))
+        info=dict(description="The ID of the ability"))
      version_group_id = Column(Integer, ForeignKey('version_groups.id'), primary_key=True, nullable=False, autoincrement=False,
      version_group_id = Column(Integer, ForeignKey('version_groups.id'), primary_key=True, nullable=False, autoincrement=False,
-        info=dict(description="The versions this flavor text is shown in"))
+        info=dict(description="The ID of the version group this flavor text is taken from"))
      flavor_text = Column(Unicode(64), nullable=False,
          info=dict(description="The actual flavor text", official=True, format='gametext'))
  
      flavor_text = Column(Unicode(64), nullable=False,
          info=dict(description="The actual flavor text", official=True, format='gametext'))
  
-class AbilityName(TableBase):
-    """Non-English official name of an ability
-    """
-    __tablename__ = 'ability_names'
-    ability_id = Column(Integer, ForeignKey('abilities.id'), primary_key=True, nullable=False, autoincrement=False,
-        info=dict(description="ID of the ability"))
-    language_id = Column(Integer, ForeignKey('languages.id'), primary_key=True, nullable=False, autoincrement=False,
-        info=dict(description="ID of the language"))
-    name = Column(Unicode(16), nullable=False,
-        info=dict(description="ID of the language", official=True, foreign=True, format='plaintext'))
-
  class Berry(TableBase):
  class Berry(TableBase):
-    """A Berry, consumable item that grows on trees
+    u"""A Berry, consumable item that grows on trees
  
  
-    For data common to all Items, such as the name, see the corresponding Item entry.
+    For data common to all items, such as the name, see the corresponding item entry.
      """
      __tablename__ = 'berries'
      id = Column(Integer, primary_key=True, nullable=False,
      """
      __tablename__ = 'berries'
      id = Column(Integer, primary_key=True, nullable=False,
-        info=dict(description="A numeric ID"))
+        info=dict(description="This Berry's in-game number"))
      item_id = Column(Integer, ForeignKey('items.id'), nullable=False,
      item_id = Column(Integer, ForeignKey('items.id'), nullable=False,
-        info=dict(description="ID of the Item this Berry corresponds to"))
+        info=dict(description="The ID of the item that represents this Berry"))
      firmness_id = Column(Integer, ForeignKey('berry_firmness.id'), nullable=False,
      firmness_id = Column(Integer, ForeignKey('berry_firmness.id'), nullable=False,
-        info=dict(description="ID of this berry's firmness"))
+        info=dict(description="The ID of this Berry's firmness category"))
      natural_gift_power = Column(Integer, nullable=True,
      natural_gift_power = Column(Integer, nullable=True,
-        info=dict(description="Power of Natural Gift when that move is used with this Berry"))
+        info=dict(description="Natural Gift's power when used with this Berry"))
      natural_gift_type_id = Column(Integer, ForeignKey('types.id'), nullable=True,
      natural_gift_type_id = Column(Integer, ForeignKey('types.id'), nullable=True,
-        info=dict(description="ID of the Type that Natural Gift will have when used with this Berry"))
+        info=dict(description="The ID of the Type that Natural Gift has when used with this Berry"))
      size = Column(Integer, nullable=False,
      size = Column(Integer, nullable=False,
-        info=dict(description=u"Size of this Berry, in millimeters"))
+        info=dict(description=u"The size of this Berry, in millimeters"))
      max_harvest = Column(Integer, nullable=False,
      max_harvest = Column(Integer, nullable=False,
-        info=dict(description="Maximum number of these berries that can grow on one tree"))
+        info=dict(description="The maximum number of these berries that can grow on one tree in Generation IV"))
      growth_time = Column(Integer, nullable=False,
      growth_time = Column(Integer, nullable=False,
-        info=dict(description="Time it takes the tree to grow one stage, in hours. Multiply by four to get overall time."))
+        info=dict(description="Time it takes the tree to grow one stage, in hours.  Berry trees go through four of these growth stages before they can be picked."))
      soil_dryness = Column(Integer, nullable=False,
      soil_dryness = Column(Integer, nullable=False,
-        info=dict(description="The speed of soil drying the tree causes"))  # XXX: What's this exactly? I'm not a good farmer
+        info=dict(description="The speed at which this Berry dries out the soil as it grows.  A higher rate means the soil dries more quickly."))
      smoothness = Column(Integer, nullable=False,
      smoothness = Column(Integer, nullable=False,
-        info=dict(description="Smoothness of this Berry, a culinary attribute. Higher is better."))
+        info=dict(description="The smoothness of this Berry, used in making Pokéblocks or Poffins"))
  
  
-class BerryFirmness(TableBase):
-    """A Berry firmness, such as "hard" or "very soft".
+class BerryFirmness(TableBase, OfficiallyNamed):
+    u"""A Berry firmness, such as "hard" or "very soft".
      """
      __tablename__ = 'berry_firmness'
      """
      __tablename__ = 'berry_firmness'
+    __singlename__ = 'berry_firmness'
      id = Column(Integer, primary_key=True, nullable=False,
      id = Column(Integer, primary_key=True, nullable=False,
-        info=dict(description="A numeric ID"))
-    name = Column(Unicode(10), nullable=False,
-        info=dict(description="English name of the firmness level", official=True, format='plaintext'))
+        info=dict(description="A unique ID for this firmness"))
+    identifier = Column(Unicode(10), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
  
  class BerryFlavor(TableBase):
  
  class BerryFlavor(TableBase):
-    """A Berry flavor level.
+    u"""A Berry flavor level.
      """
      __tablename__ = 'berry_flavors'
      berry_id = Column(Integer, ForeignKey('berries.id'), primary_key=True, nullable=False, autoincrement=False,
      """
      __tablename__ = 'berry_flavors'
      berry_id = Column(Integer, ForeignKey('berries.id'), primary_key=True, nullable=False, autoincrement=False,
-        info=dict(description="ID of the berry"))
+        info=dict(description="The ID of the berry"))
      contest_type_id = Column(Integer, ForeignKey('contest_types.id'), primary_key=True, nullable=False, autoincrement=False,
      contest_type_id = Column(Integer, ForeignKey('contest_types.id'), primary_key=True, nullable=False, autoincrement=False,
-        info=dict(description="ID of the flavor"))
+        info=dict(description="The ID of the flavor"))
      flavor = Column(Integer, nullable=False,
      flavor = Column(Integer, nullable=False,
-        info=dict(description="Level of the flavor in the berry"))
+        info=dict(description="The level of the flavor in the berry"))
  
  class ContestCombo(TableBase):
  
  class ContestCombo(TableBase):
-    """Combo of two moves in a Contest.
+    u"""Combo of two moves in a Contest.
      """
      __tablename__ = 'contest_combos'
      first_move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False, autoincrement=False,
      """
      __tablename__ = 'contest_combos'
      first_move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False, autoincrement=False,
-        info=dict(description="ID of the first move in the combo"))
+        info=dict(description="The ID of the first move in the combo"))
      second_move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False, autoincrement=False,
      second_move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False, autoincrement=False,
-        info=dict(description="ID of the second and final move in the combo"))
+        info=dict(description="The ID of the second and final move in the combo"))
  
  class ContestEffect(TableBase):
  
  class ContestEffect(TableBase):
-    """Effect of a move when used in a Contest.
+    u"""Effect of a move when used in a Contest.
      """
      __tablename__ = 'contest_effects'
      """
      __tablename__ = 'contest_effects'
+    __singlename__ = 'contest_effect'
      id = Column(Integer, primary_key=True, nullable=False,
      id = Column(Integer, primary_key=True, nullable=False,
-        info=dict(description="A numeric ID"))
+        info=dict(description="A unique ID for this effect"))
      appeal = Column(SmallInteger, nullable=False,
          info=dict(description="The base number of hearts the user of this move gets"))
      jam = Column(SmallInteger, nullable=False,
          info=dict(description="The base number of hearts the user's opponent loses"))
      appeal = Column(SmallInteger, nullable=False,
          info=dict(description="The base number of hearts the user of this move gets"))
      jam = Column(SmallInteger, nullable=False,
          info=dict(description="The base number of hearts the user's opponent loses"))
-    flavor_text = Column(Unicode(64), nullable=False,
-        info=dict(description="English in-game description of this effect", official=True, format='gametext'))
-    effect = Column(Unicode(255), nullable=False,
-        info=dict(description="Detailed description of the effect", format='markdown'))
+    flavor_text = ProseColumn(Unicode(64), plural='flavor_texts', nullable=False,
+        info=dict(description="The in-game description of this effect", official=True, format='gametext'))
+    effect = ProseColumn(Unicode(255), plural='effects', nullable=False,
+        info=dict(description="A detailed description of the effect", format='plaintext'))
  
  
-class ContestType(TableBase):
-    u"""A Contest type, such as "cool" or "smart". Also functions as Berry flavor and Pokéblock color."""
+class ContestType(TableBase, OfficiallyNamed):
+    u"""A Contest type, such as "cool" or "smart", and their associated Berry flavors and Pokéblock colors.
+    """
      __tablename__ = 'contest_types'
      __tablename__ = 'contest_types'
+    __singlename__ = 'contest_type'
      id = Column(Integer, primary_key=True, nullable=False,
      id = Column(Integer, primary_key=True, nullable=False,
-        info=dict(description="A numeric ID"))
-    name = Column(Unicode(6), nullable=False,
-        info=dict(description="The English name of the Contest type", official=True, format='identifier'))
-    flavor = Column(Unicode(6), nullable=False,
-        info=dict(description="The English name of the corresponding Berry flavor", official=True, format='identifier'))
-    color = Column(Unicode(6), nullable=False,
-        info=dict(description="The English name of the corresponding Pokéblock color", official=True, format='identifier'))
+        info=dict(description="A unique ID for this Contest type"))
+    identifier = Column(Unicode(6), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
+    flavor = TextColumn(Unicode(6), nullable=False, plural='flavors',
+        info=dict(description="The name of the corresponding Berry flavor", official=True, format='plaintext'))
+    color = TextColumn(Unicode(6), nullable=False, plural='colors',
+        info=dict(description=u"The name of the corresponding Pokéblock color", official=True, format='plaintext'))
  
  
-class EggGroup(TableBase):
-    """An Egg group. Usually, two Pokémon can breed if they share an Egg Group.
+class EggGroup(TableBase, UnofficiallyNamed):
+    u"""An Egg group. Usually, two Pokémon can breed if they share an Egg Group.
  
      (exceptions are the Ditto and No Eggs groups)
      """
      __tablename__ = 'egg_groups'
  
      (exceptions are the Ditto and No Eggs groups)
      """
      __tablename__ = 'egg_groups'
+    __singlename__ = 'egg_group'
      id = Column(Integer, primary_key=True, nullable=False,
      id = Column(Integer, primary_key=True, nullable=False,
-        info=dict(description="A numeric ID"))
-    name = Column(Unicode(16), nullable=False,
-        info=dict(description="The English “official” name. One NPC in Stadium uses these names; they are pretty bad.", official=True, format='identifier'))
+        info=dict(description="A unique ID for this group"))
+    identifier = Column(Unicode(16), nullable=False,
+        info=dict(description=u"An identifier.", format='identifier'))
  
  class Encounter(TableBase):
  
  class Encounter(TableBase):
-    """Encounters with wild Pokémon.
+    u"""Encounters with wild Pokémon.
  
      Bear with me, here.
  
  
      Bear with me, here.
  
@@ -195,11 +245,11 @@ class Encounter(TableBase):
  
      __tablename__ = 'encounters'
      id = Column(Integer, primary_key=True, nullable=False,
  
      __tablename__ = 'encounters'
      id = Column(Integer, primary_key=True, nullable=False,
-        info=dict(description="A numeric ID"))
+        info=dict(description="A unique ID for this encounter"))
      version_id = Column(Integer, ForeignKey('versions.id'), nullable=False, autoincrement=False,
      version_id = Column(Integer, ForeignKey('versions.id'), nullable=False, autoincrement=False,
-        info=dict(description="The ID of the Version this applies to"))
+        info=dict(description="The ID of the version this applies to"))
      location_area_id = Column(Integer, ForeignKey('location_areas.id'), nullable=False, autoincrement=False,
      location_area_id = Column(Integer, ForeignKey('location_areas.id'), nullable=False, autoincrement=False,
-        info=dict(description="The ID of the Location of this encounter"))
+        info=dict(description="The ID of the location of this encounter"))
      encounter_slot_id = Column(Integer, ForeignKey('encounter_slots.id'), nullable=False, autoincrement=False,
          info=dict(description="The ID of the encounter slot, which determines terrain and rarity"))
      pokemon_id = Column(Integer, ForeignKey('pokemon.id'), nullable=False, autoincrement=False,
      encounter_slot_id = Column(Integer, ForeignKey('encounter_slots.id'), nullable=False, autoincrement=False,
          info=dict(description="The ID of the encounter slot, which determines terrain and rarity"))
      pokemon_id = Column(Integer, ForeignKey('pokemon.id'), nullable=False, autoincrement=False,
@@ -209,51 +259,54 @@ class Encounter(TableBase):
      max_level = Column(Integer, nullable=False, autoincrement=False,
          info=dict(description=u"The maxmum level of the encountered Pokémon"))
  
      max_level = Column(Integer, nullable=False, autoincrement=False,
          info=dict(description=u"The maxmum level of the encountered Pokémon"))
  
-class EncounterCondition(TableBase):
-    """A conditions in the game world that affects pokémon encounters, such as time of day.
+class EncounterCondition(TableBase, UnofficiallyNamed):
+    u"""A conditions in the game world that affects Pokémon encounters, such as time of day.
      """
  
      __tablename__ = 'encounter_conditions'
      """
  
      __tablename__ = 'encounter_conditions'
+    __singlename__ = 'encounter_condition'
      id = Column(Integer, primary_key=True, nullable=False,
      id = Column(Integer, primary_key=True, nullable=False,
-        info=dict(description="A numeric ID"))
-    name = Column(Unicode(64), nullable=False,
-        info=dict(description="An English name of the condition", format='plaintext'))
+        info=dict(description="A unique ID for this condition"))
+    identifier = Column(Unicode(64), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
  
  
-class EncounterConditionValue(TableBase):
-    """A possible state for a condition; for example, the state of 'swarm' could be 'swarm' or 'no swarm'.
+class EncounterConditionValue(TableBase, UnofficiallyNamed):
+    u"""A possible state for a condition; for example, the state of 'swarm' could be 'swarm' or 'no swarm'.
      """
  
      __tablename__ = 'encounter_condition_values'
      """
  
      __tablename__ = 'encounter_condition_values'
+    __singlename__ = 'encounter_condition_value'
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      encounter_condition_id = Column(Integer, ForeignKey('encounter_conditions.id'), primary_key=False, nullable=False, autoincrement=False,
          info=dict(description="The ID of the encounter condition this is a value of"))
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      encounter_condition_id = Column(Integer, ForeignKey('encounter_conditions.id'), primary_key=False, nullable=False, autoincrement=False,
          info=dict(description="The ID of the encounter condition this is a value of"))
-    name = Column(Unicode(64), nullable=False,
-        info=dict(description="An english name of this value", format='plaintext'))
+    identifier = Column(Unicode(64), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
      is_default = Column(Boolean, nullable=False,
      is_default = Column(Boolean, nullable=False,
-        info=dict(description='Set if this value is "default" or "normal" in some sense'))
+        info=dict(description='Set if this value is the default state for the condition'))
  
  class EncounterConditionValueMap(TableBase):
  
  class EncounterConditionValueMap(TableBase):
-    """Maps encounters to the specific conditions under which they occur."""
-
+    u"""Maps encounters to the specific conditions under which they occur.
+    """
      __tablename__ = 'encounter_condition_value_map'
      encounter_id = Column(Integer, ForeignKey('encounters.id'), primary_key=True, nullable=False, autoincrement=False,
      __tablename__ = 'encounter_condition_value_map'
      encounter_id = Column(Integer, ForeignKey('encounters.id'), primary_key=True, nullable=False, autoincrement=False,
-        info=dict(description="ID of the encounter"))
+        info=dict(description="The ID of the encounter"))
      encounter_condition_value_id = Column(Integer, ForeignKey('encounter_condition_values.id'), primary_key=True, nullable=False, autoincrement=False,
      encounter_condition_value_id = Column(Integer, ForeignKey('encounter_condition_values.id'), primary_key=True, nullable=False, autoincrement=False,
-        info=dict(description="ID of the encounter condition value"))
+        info=dict(description="The ID of the encounter condition value"))
  
  
-class EncounterTerrain(TableBase):
-    """A way the player can enter a wild encounter, e.g., surfing, fishing, or walking through tall grass.
+class EncounterTerrain(TableBase, UnofficiallyNamed):
+    u"""A way the player can enter a wild encounter, e.g., surfing, fishing, or walking through tall grass.
      """
  
      __tablename__ = 'encounter_terrain'
      """
  
      __tablename__ = 'encounter_terrain'
+    __singlename__ = __tablename__
      id = Column(Integer, primary_key=True, nullable=False,
      id = Column(Integer, primary_key=True, nullable=False,
-        info=dict(description="A numeric ID"))
-    name = Column(Unicode(64), nullable=False,
-        info=dict(description="An english name of this terrain", format='plaintext'))
+        info=dict(description="A unique ID for the terrain"))
+    identifier = Column(Unicode(64), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
  
  class EncounterSlot(TableBase):
  
  class EncounterSlot(TableBase):
-    """Aan abstract "slot" within a terrain, associated with both some set of conditions and a rarity.
+    u"""An abstract "slot" within a terrain, associated with both some set of conditions and a rarity.
  
      Note that there are two encounters per slot, so the rarities will only add
      up to 50.
  
      Note that there are two encounters per slot, so the rarities will only add
      up to 50.
@@ -261,27 +314,19 @@ class EncounterSlot(TableBase):
  
      __tablename__ = 'encounter_slots'
      id = Column(Integer, primary_key=True, nullable=False,
  
      __tablename__ = 'encounter_slots'
      id = Column(Integer, primary_key=True, nullable=False,
-        info=dict(description="A numeric ID"))
+        info=dict(description="A unique ID for this slot"))
      version_group_id = Column(Integer, ForeignKey('version_groups.id'), nullable=False, autoincrement=False,
      version_group_id = Column(Integer, ForeignKey('version_groups.id'), nullable=False, autoincrement=False,
-        info=dict(description="The ID of the Version group this slot is in"))
+        info=dict(description="The ID of the version group this slot is in"))
      encounter_terrain_id = Column(Integer, ForeignKey('encounter_terrain.id'), primary_key=False, nullable=False, autoincrement=False,
          info=dict(description="The ID of the terrain"))
      encounter_terrain_id = Column(Integer, ForeignKey('encounter_terrain.id'), primary_key=False, nullable=False, autoincrement=False,
          info=dict(description="The ID of the terrain"))
-    slot = Column(Integer, nullable=True)
-        # XXX: What is this?
+    slot = Column(Integer, nullable=True,
+        info=dict(description="This slot's order for the location and terrain"))
      rarity = Column(Integer, nullable=False,
      rarity = Column(Integer, nullable=False,
-        info=dict(description="The chance of the encounter, in percent"))  # XXX: It is in percent, right? I'm confused.
-
-class EncounterSlotCondition(TableBase):
-    """A condition that affects an encounter slot."""
-
-    __tablename__ = 'encounter_slot_conditions'
-    encounter_slot_id = Column(Integer, ForeignKey('encounter_slots.id'), primary_key=True, nullable=False, autoincrement=False,
-        info=dict(description="The ID of the encounter slot"))
-    encounter_condition_id = Column(Integer, ForeignKey('encounter_conditions.id'), primary_key=True, nullable=False, autoincrement=False,
-        info=dict(description="The ID of the encounter condition"))
+        info=dict(description="The chance of the encounter as a percentage"))
  
  class EvolutionChain(TableBase):
  
  class EvolutionChain(TableBase):
-    """A family of pokémon that are linked by evolution"""
+    u"""A family of Pokémon that are linked by evolution
+    """
      __tablename__ = 'evolution_chains'
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      __tablename__ = 'evolution_chains'
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
@@ -290,16 +335,19 @@ class EvolutionChain(TableBase):
      baby_trigger_item_id = Column(Integer, ForeignKey('items.id'), nullable=True,
          info=dict(description="Item that a parent must hold while breeding to produce a baby"))
  
      baby_trigger_item_id = Column(Integer, ForeignKey('items.id'), nullable=True,
          info=dict(description="Item that a parent must hold while breeding to produce a baby"))
  
-class EvolutionTrigger(TableBase):
-    """An evolution type, such as "level" or "trade"."""
+class EvolutionTrigger(TableBase, UnofficiallyNamed):
+    u"""An evolution type, such as "level" or "trade".
+    """
      __tablename__ = 'evolution_triggers'
      __tablename__ = 'evolution_triggers'
+    __singlename__ = 'evolution_trigger'
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      identifier = Column(Unicode(16), nullable=False,
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      identifier = Column(Unicode(16), nullable=False,
-        info=dict(description="An English identifier", format='identifier'))
+        info=dict(description="An identifier", format='identifier'))
  
  class Experience(TableBase):
  
  class Experience(TableBase):
-    """EXP needed for a certain level with a certain growth rate"""
+    u"""EXP needed for a certain level with a certain growth rate
+    """
      __tablename__ = 'experience'
      growth_rate_id = Column(Integer, ForeignKey('growth_rates.id'), primary_key=True, nullable=False,
          info=dict(description="ID of the growth rate"))
      __tablename__ = 'experience'
      growth_rate_id = Column(Integer, ForeignKey('growth_rates.id'), primary_key=True, nullable=False,
          info=dict(description="ID of the growth rate"))
@@ -308,36 +356,41 @@ class Experience(TableBase):
      experience = Column(Integer, nullable=False,
          info=dict(description="The number of EXP points needed to get to that level"))
  
      experience = Column(Integer, nullable=False,
          info=dict(description="The number of EXP points needed to get to that level"))
  
-class Generation(TableBase):
-    u"""A Generation of the pokémon franchise"""
+class Generation(TableBase, OfficiallyNamed):
+    u"""A Generation of the Pokémon franchise
+    """
      __tablename__ = 'generations'
      __tablename__ = 'generations'
+    __singlename__ = 'generation'
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      main_region_id = Column(Integer, ForeignKey('regions.id'),
          info=dict(description="ID of the region this generation's main games take place in"))
      canonical_pokedex_id = Column(Integer, ForeignKey('pokedexes.id'),
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      main_region_id = Column(Integer, ForeignKey('regions.id'),
          info=dict(description="ID of the region this generation's main games take place in"))
      canonical_pokedex_id = Column(Integer, ForeignKey('pokedexes.id'),
-        info=dict(description=u"ID of the pokédex this generation's main games use by default"))
-    name = Column(Unicode(16), nullable=False,
-        info=dict(description=u'An English name of this generation, such as "Generation IV"', format='plaintext'))
+        info=dict(description=u"ID of the Pokédex this generation's main games use by default"))
+    identifier = Column(Unicode(16), nullable=False,
+        info=dict(description=u'An identifier', format='identifier'))
  
  
-class GrowthRate(TableBase):
-    u"""Growth rate of a pokémon, i.e. the EXP → level function."""
+class GrowthRate(TableBase, UnofficiallyNamed):
+    u"""Growth rate of a Pokémon, i.e. the EXP → level function.
+    """
      __tablename__ = 'growth_rates'
      __tablename__ = 'growth_rates'
+    __singlename__ = 'growth_rate'
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
-    name = Column(Unicode(20), nullable=False,
-        info=dict(description="A name for the", format='identifier'))
+    identifier = Column(Unicode(20), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
      formula = Column(Unicode(500), nullable=False,
          info=dict(description="The formula", format='latex'))
  
      formula = Column(Unicode(500), nullable=False,
          info=dict(description="The formula", format='latex'))
  
-class Item(TableBase):
-    """An Item from the games, like "Poké Ball" or "Bicycle"."""
+class Item(TableBase, OfficiallyNamed):
+    u"""An Item from the games, like "Poké Ball" or "Bicycle".
+    """
      __tablename__ = 'items'
      __singlename__ = 'item'
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      __tablename__ = 'items'
      __singlename__ = 'item'
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
-    name = Column(Unicode(20), nullable=False,
-        info=dict(description="The English name of the item", official=True, format='plaintext'))
+    identifier = Column(Unicode(20), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
      category_id = Column(Integer, ForeignKey('item_categories.id'), nullable=False,
          info=dict(description="ID of a category this item belongs to"))
      cost = Column(Integer, nullable=False,
      category_id = Column(Integer, ForeignKey('item_categories.id'), nullable=False,
          info=dict(description="ID of a category this item belongs to"))
      cost = Column(Integer, nullable=False,
@@ -346,46 +399,56 @@ class Item(TableBase):
          info=dict(description=u"Power of the move Fling when used with this item."))
      fling_effect_id = Column(Integer, ForeignKey('item_fling_effects.id'), nullable=True,
          info=dict(description=u"ID of the fling-effect of the move Fling when used with this item. Note that these are different from move effects."))
          info=dict(description=u"Power of the move Fling when used with this item."))
      fling_effect_id = Column(Integer, ForeignKey('item_fling_effects.id'), nullable=True,
          info=dict(description=u"ID of the fling-effect of the move Fling when used with this item. Note that these are different from move effects."))
-    effect = Column(markdown.MarkdownColumn(5120), nullable=False,
-        info=dict(description=u"Detailed English description of the item's effect.", format='markdown'))
+    short_effect = ProseColumn(Unicode(256), plural='short_effects', nullable=False,
+        info=dict(description="A short summary of the effect", format='plaintext'))
+    effect = ProseColumn(markdown.MarkdownColumn(5120), plural='effects', nullable=False,
+        info=dict(description=u"Detailed description of the item's effect.", format='markdown'))
  
      @property
      def appears_underground(self):
  
      @property
      def appears_underground(self):
-        """True if the item appears underground, as specified by the appropriate flag"""
+        u"""True if the item appears underground, as specified by the appropriate flag
+        """
          return any(flag.identifier == u'underground' for flag in self.flags)
  
          return any(flag.identifier == u'underground' for flag in self.flags)
  
-class ItemCategory(TableBase):
-    """An item category"""
+class ItemCategory(TableBase, UnofficiallyNamed):
+    u"""An item category
+    """
      # XXX: This is fanon, right?
      __tablename__ = 'item_categories'
      # XXX: This is fanon, right?
      __tablename__ = 'item_categories'
+    __singlename__ = 'item_category'
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      pocket_id = Column(Integer, ForeignKey('item_pockets.id'), nullable=False,
          info=dict(description="ID of the pocket these items go to"))
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      pocket_id = Column(Integer, ForeignKey('item_pockets.id'), nullable=False,
          info=dict(description="ID of the pocket these items go to"))
-    name = Column(Unicode(16), nullable=False,
-        info=dict(description="English name of the category", format='plaintext'))
+    identifier = Column(Unicode(16), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
  
  
-class ItemFlag(TableBase):
-    """An item attribute such as "consumable" or "holdable"."""
+class ItemFlag(TableBase, UnofficiallyNamed):
+    u"""An item attribute such as "consumable" or "holdable".
+    """
      __tablename__ = 'item_flags'
      __tablename__ = 'item_flags'
+    __singlename__ = 'item_flag'
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      identifier = Column(Unicode(24), nullable=False,
          info=dict(description="Identifier of the flag", format='identifier'))
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      identifier = Column(Unicode(24), nullable=False,
          info=dict(description="Identifier of the flag", format='identifier'))
-    name = Column(Unicode(64), nullable=False,
-        info=dict(description="Short English description of the flag", format='plaintext'))
+    description = ProseColumn(Unicode(64), plural='descriptions', nullable=False,
+        info=dict(description="Short description of the flag", format='plaintext'))
  
  class ItemFlagMap(TableBase):
  
  class ItemFlagMap(TableBase):
-    """Maps an item flag to its item."""
+    u"""Maps an item flag to its item.
+    """
      __tablename__ = 'item_flag_map'
      item_id = Column(Integer, ForeignKey('items.id'), primary_key=True, autoincrement=False, nullable=False,
          info=dict(description="The ID of the item"))
      item_flag_id = Column(Integer, ForeignKey('item_flags.id'), primary_key=True, autoincrement=False, nullable=False,
          info=dict(description="The ID of the item flag"))
  
      __tablename__ = 'item_flag_map'
      item_id = Column(Integer, ForeignKey('items.id'), primary_key=True, autoincrement=False, nullable=False,
          info=dict(description="The ID of the item"))
      item_flag_id = Column(Integer, ForeignKey('item_flags.id'), primary_key=True, autoincrement=False, nullable=False,
          info=dict(description="The ID of the item flag"))
  
-class ItemFlavorText(TableBase):
-    """An in-game description of an item"""
+class ItemFlavorText(TableBase, LanguageSpecific):
+    u"""An in-game description of an item
+    """
      __tablename__ = 'item_flavor_text'
      __tablename__ = 'item_flavor_text'
+    __singlename__ = 'item_flavor_text'
      item_id = Column(Integer, ForeignKey('items.id'), primary_key=True, autoincrement=False, nullable=False,
          info=dict(description="The ID of the item"))
      version_group_id = Column(Integer, ForeignKey('version_groups.id'), primary_key=True, autoincrement=False, nullable=False,
      item_id = Column(Integer, ForeignKey('items.id'), primary_key=True, autoincrement=False, nullable=False,
          info=dict(description="The ID of the item"))
      version_group_id = Column(Integer, ForeignKey('version_groups.id'), primary_key=True, autoincrement=False, nullable=False,
@@ -394,15 +457,18 @@ class ItemFlavorText(TableBase):
          info=dict(description="The flavor text itself", official=True, format='gametext'))
  
  class ItemFlingEffect(TableBase):
          info=dict(description="The flavor text itself", official=True, format='gametext'))
  
  class ItemFlingEffect(TableBase):
-    """An effect of the move Fling when used with a specific item"""
+    u"""An effect of the move Fling when used with a specific item
+    """
      __tablename__ = 'item_fling_effects'
      __tablename__ = 'item_fling_effects'
+    __singlename__ = 'item_fling_effect'
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
-    effect = Column(Unicode(255), nullable=False,
-        info=dict(description="English description of the effect", format='plaintext'))
+    effect = ProseColumn(Unicode(255), plural='effects', nullable=False,
+        info=dict(description="Description of the effect", format='plaintext'))
  
  class ItemInternalID(TableBase):
  
  class ItemInternalID(TableBase):
-    """The internal ID number a game uses for an item"""
+    u"""The internal ID number a game uses for an item
+    """
      __tablename__ = 'item_internal_ids'
      item_id = Column(Integer, ForeignKey('items.id'), primary_key=True, autoincrement=False, nullable=False,
          info=dict(description="The database ID of the item"))
      __tablename__ = 'item_internal_ids'
      item_id = Column(Integer, ForeignKey('items.id'), primary_key=True, autoincrement=False, nullable=False,
          info=dict(description="The database ID of the item"))
@@ -411,163 +477,349 @@ class ItemInternalID(TableBase):
      internal_id = Column(Integer, nullable=False,
          info=dict(description="Internal ID of the item in the generation"))
  
      internal_id = Column(Integer, nullable=False,
          info=dict(description="Internal ID of the item in the generation"))
  
-class ItemName(TableBase):
-    """A non-English name of an item"""
-    __tablename__ = 'item_names'
-    item_id = Column(Integer, ForeignKey('items.id'), primary_key=True, nullable=False, autoincrement=False,
-        info=dict(description="The ID of the item"))
-    language_id = Column(Integer, ForeignKey('languages.id'), primary_key=True, nullable=False, autoincrement=False,
-        info=dict(description="The ID of the language"))
-    name = Column(Unicode(16), nullable=False,
-        info=dict(description="The name of the item in this language", foreign=True, format='plaintext'))
-
-class ItemPocket(TableBase):
-    """A pocket that categorizes items"""
+class ItemPocket(TableBase, OfficiallyNamed):
+    u"""A pocket that categorizes items
+    """
      __tablename__ = 'item_pockets'
      __tablename__ = 'item_pockets'
+    __singlename__ = 'item_pocket'
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      identifier = Column(Unicode(16), nullable=False,
          info=dict(description="An identifier of this pocket", format='identifier'))
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      identifier = Column(Unicode(16), nullable=False,
          info=dict(description="An identifier of this pocket", format='identifier'))
-    name = Column(Unicode(16), nullable=False,
-        info=dict(description="A numeric ID", format='plaintext'))
  
  
-class Language(TableBase):
-    u"""A language the Pokémon games have been transleted into; except English"""
+class Language(TableBase, OfficiallyNamed):
+    u"""A language the Pokémon games have been transleted into
+    """
      __tablename__ = 'languages'
      __tablename__ = 'languages'
+    __singlename__ = 'language'
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      iso639 = Column(Unicode(2), nullable=False,
      id = Column(Integer, primary_key=True, nullable=False,
          info=dict(description="A numeric ID"))
      iso639 = Column(Unicode(2), nullable=False,
-        info=dict(description="The two-letter code of the country where this language is spoken. Note that it is not unique."))
+        info=dict(description="The two-letter code of the country where this language is spoken. Note that it is not unique.", format='identifier'))
      iso3166 = Column(Unicode(2), nullable=False,
      iso3166 = Column(Unicode(2), nullable=False,
-        info=dict(description="The two-letter code of the language. Note that it is not unique."))
-    name = Column(Unicode(16), nullable=False,
-        info=dict(description="The English name of the language", format='plaintext'))
-
-class Location(TableBase):
+        info=dict(description="The two-letter code of the language. Note that it is not unique.", format='identifier'))
+    identifier = Column(Unicode(16), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
+    official = Column(Boolean, nullable=False, index=True,
+        info=dict(description=u"True iff games are produced in the language."))
+    order = Column(Integer, nullable=True,
+        info=dict(description=u"Order for sorting in foreign name lists."))
+
+    # Languages compare equal to its identifier, so a dictionary of
+    # translations, with a Language as the key, can be indexed by the identifier
+    def __eq__(self, other):
+        try:
+            return (
+                    self is other or
+                    self.identifier == other or
+                    self.identifier == other.identifier
+                )
+        except AttributeError:
+            return NotImplemented
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __hash__(self):
+        return hash(self.identifier)
+
+class Location(TableBase, OfficiallyNamed):
+    u"""A place in the Pokémon world
+    """
      __tablename__ = 'locations'
      __singlename__ = 'location'
      __tablename__ = 'locations'
      __singlename__ = 'location'
-    id = Column(Integer, primary_key=True, nullable=False)
-    region_id = Column(Integer, ForeignKey('regions.id'))
-    name = Column(Unicode(64), nullable=False)
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description="A numeric ID"))
+    region_id = Column(Integer, ForeignKey('regions.id'),
+        info=dict(description="ID of the region this location is in"))
+    identifier = Column(Unicode(64), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
  
  
-class LocationArea(TableBase):
+class LocationArea(TableBase, UnofficiallyNamed):
+    u"""A sub-area of a location
+    """
      __tablename__ = 'location_areas'
      __tablename__ = 'location_areas'
-    id = Column(Integer, primary_key=True, nullable=False)
-    location_id = Column(Integer, ForeignKey('locations.id'), nullable=False)
-    internal_id = Column(Integer, nullable=False)
-    name = Column(Unicode(64), nullable=True)
+    __singlename__ = 'location_area'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description="A numeric ID"))
+    location_id = Column(Integer, ForeignKey('locations.id'), nullable=False,
+        info=dict(description="ID of the location this area is part of"))
+    internal_id = Column(Integer, nullable=False,
+        info=dict(description="ID the games ude for this area"))
+    identifier = Column(Unicode(64), nullable=True,
+        info=dict(description="An identifier", format='identifier'))
  
  class LocationAreaEncounterRate(TableBase):
  
  class LocationAreaEncounterRate(TableBase):
+    # XXX: What's this exactly? Someone add the docstring & revise the descriptions
      __tablename__ = 'location_area_encounter_rates'
      __tablename__ = 'location_area_encounter_rates'
-    location_area_id = Column(Integer, ForeignKey('location_areas.id'), primary_key=True, nullable=False, autoincrement=False)
-    encounter_terrain_id = Column(Integer, ForeignKey('encounter_terrain.id'), primary_key=True, nullable=False, autoincrement=False)
-    version_id = Column(Integer, ForeignKey('versions.id'), primary_key=True, autoincrement=False)
-    rate = Column(Integer, nullable=True)
+    location_area_id = Column(Integer, ForeignKey('location_areas.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description="ID of the area"))
+    encounter_terrain_id = Column(Integer, ForeignKey('encounter_terrain.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description="ID of the terrain"))
+    version_id = Column(Integer, ForeignKey('versions.id'), primary_key=True, autoincrement=False,
+        info=dict(description="ID of the version"))
+    rate = Column(Integer, nullable=True,
+        info=dict(description="The encounter rate"))  # units?
  
  class LocationInternalID(TableBase):
  
  class LocationInternalID(TableBase):
+    u"""IDs the games use internally for locations
+    """
      __tablename__ = 'location_internal_ids'
      __tablename__ = 'location_internal_ids'
-    location_id = Column(Integer, ForeignKey('locations.id'), nullable=False, primary_key=True)
-    generation_id = Column(Integer, ForeignKey('generations.id'), nullable=False, primary_key=True)
-    internal_id = Column(Integer, nullable=False)
+    location_id = Column(Integer, ForeignKey('locations.id'), nullable=False, primary_key=True,
+        info=dict(description="Database ID of the locaion"))
+    generation_id = Column(Integer, ForeignKey('generations.id'), nullable=False, primary_key=True,
+        info=dict(description="ID of the generation this entry to"))
+    internal_id = Column(Integer, nullable=False,
+        info=dict(description="Internal game ID of the location"))
  
  class Machine(TableBase):
  
  class Machine(TableBase):
+    u"""A TM or HM; numbered item that can teach a move to a Pokémon
+    """
      __tablename__ = 'machines'
      __tablename__ = 'machines'
-    machine_number = Column(Integer, primary_key=True, nullable=False, autoincrement=False)
-    version_group_id = Column(Integer, ForeignKey('version_groups.id'), primary_key=True, nullable=False, autoincrement=False)
-    item_id = Column(Integer, ForeignKey('items.id'), nullable=False)
-    move_id = Column(Integer, ForeignKey('moves.id'), nullable=False)
+    machine_number = Column(Integer, primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description="Number of the machine for TMs, or 100 + the munber for HMs"))
+    version_group_id = Column(Integer, ForeignKey('version_groups.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description="Versions this entry applies to"))
+    item_id = Column(Integer, ForeignKey('items.id'), nullable=False,
+        info=dict(description="ID of the corresponding Item"))
+    move_id = Column(Integer, ForeignKey('moves.id'), nullable=False,
+        info=dict(description="ID of the taught move"))
  
      @property
      def is_hm(self):
  
      @property
      def is_hm(self):
+        u"""True if this machine is a HM, False if it's a TM
+        """
          return self.machine_number >= 100
  
          return self.machine_number >= 100
  
-class MoveBattleStyle(TableBase):
+class MoveBattleStyle(TableBase, UnofficiallyNamed):
+    u"""A battle style of a move"""  # XXX: Explain better
      __tablename__ = 'move_battle_styles'
      __tablename__ = 'move_battle_styles'
-    id = Column(Integer, primary_key=True, nullable=False)
-    name = Column(Unicode(8), nullable=False)
+    __singlename__ = 'move_battle_style'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description="A numeric ID"))
+    identifier = Column(Unicode(8), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
  
  
-class MoveEffectCategory(TableBase):
+class MoveEffectCategory(TableBase, UnofficiallyNamed):
+    u"""Category of a move effect
+    """
      __tablename__ = 'move_effect_categories'
      __tablename__ = 'move_effect_categories'
-    id = Column(Integer, primary_key=True, nullable=False)
-    name = Column(Unicode(64), nullable=False)
-    can_affect_user = Column(Boolean, nullable=False)
+    __singlename__ = 'move_effect_category'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description="A numeric ID"))
+    identifier = Column(Unicode(64), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
+    can_affect_user = Column(Boolean, nullable=False,
+        info=dict(description="Set if the user can be affected"))
  
  class MoveEffectCategoryMap(TableBase):
  
  class MoveEffectCategoryMap(TableBase):
+    u"""Maps a move effect category to a move effect
+    """
      __tablename__ = 'move_effect_category_map'
      __tablename__ = 'move_effect_category_map'
-    move_effect_id = Column(Integer, ForeignKey('move_effects.id'), primary_key=True, nullable=False)
-    move_effect_category_id = Column(Integer, ForeignKey('move_effect_categories.id'), primary_key=True, nullable=False)
-    affects_user = Column(Boolean, primary_key=True, nullable=False)
-
-class MoveDamageClass(TableBase):
+    move_effect_id = Column(Integer, ForeignKey('move_effects.id'), primary_key=True, nullable=False,
+        info=dict(description="ID of the move effect"))
+    move_effect_category_id = Column(Integer, ForeignKey('move_effect_categories.id'), primary_key=True, nullable=False,
+        info=dict(description="ID of the category"))
+    affects_user = Column(Boolean, primary_key=True, nullable=False,
+        info=dict(description="Set if the user is affected"))
+
+class MoveDamageClass(TableBase, UnofficiallyNamed):
+    u"""Any of the damage classes moves can have, i.e. physical, special, or non-damaging.
+    """
      __tablename__ = 'move_damage_classes'
      __tablename__ = 'move_damage_classes'
-    id = Column(Integer, primary_key=True, nullable=False)
-    name = Column(Unicode(8), nullable=False)
-    description = Column(Unicode(64), nullable=False)
+    __singlename__ = 'move_damage_class'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description="A numeric ID"))
+    identifier = Column(Unicode(16), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
+    description = ProseColumn(Unicode(64), plural='descriptions', nullable=False,
+        info=dict(description="A description of the class", format='plaintext'))
  
  class MoveEffect(TableBase):
  
  class MoveEffect(TableBase):
+    u"""An effect of a move
+    """
      __tablename__ = 'move_effects'
      __tablename__ = 'move_effects'
-    id = Column(Integer, primary_key=True, nullable=False)
-    short_effect = Column(Unicode(256), nullable=False)
-    effect = Column(Unicode(5120), nullable=False)
+    __singlename__ = 'move_effect'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description="A numeric ID"))
+    short_effect = ProseColumn(Unicode(256), plural='short_effects', nullable=False,
+        info=dict(description="A short summary of the effect", format='plaintext'))
+    effect = ProseColumn(Unicode(5120), plural='effects', nullable=False,
+        info=dict(description="A detailed description of the effect", format='plaintext'))
+
+class MoveEffectChangelog(TableBase):
+    """History of changes to move effects across main game versions."""
+    __tablename__ = 'move_effect_changelog'
+    __singlename__ = 'move_effect_changelog'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description="A numeric ID"))
+    effect_id = Column(Integer, ForeignKey('move_effects.id'), primary_key=True, nullable=False,
+        info=dict(description="The ID of the effect that changed"))
+    changed_in_version_group_id = Column(Integer, ForeignKey('version_groups.id'), primary_key=True, nullable=False,
+        info=dict(description="The ID of the version group in which the effect changed"))
+    effect = ProseColumn(markdown.MarkdownColumn(512), plural='effects', nullable=False,
+        info=dict(description="A description of the old behavior", format='markdown'))
  
  class MoveFlag(TableBase):
  
  class MoveFlag(TableBase):
+    u"""Maps a move flag to a move
+    """
+    # XXX: Other flags have a ___Flag class for the actual flag and ___FlagMap for the map,
+    # these, somewhat confusingly, have MoveFlagType and MoveFlag
      __tablename__ = 'move_flags'
      __tablename__ = 'move_flags'
-    move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False, autoincrement=False)
-    move_flag_type_id = Column(Integer, ForeignKey('move_flag_types.id'), primary_key=True, nullable=False, autoincrement=False)
+    move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description="ID of the move"))
+    move_flag_type_id = Column(Integer, ForeignKey('move_flag_types.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description="ID of the flag"))
  
  
-class MoveFlagType(TableBase):
+class MoveFlagType(TableBase, UnofficiallyNamed):
+    u"""A Move attribute such as "snatchable" or "contact".
+    """
      __tablename__ = 'move_flag_types'
      __tablename__ = 'move_flag_types'
-    id = Column(Integer, primary_key=True, nullable=False)
-    identifier = Column(Unicode(16), nullable=False)
-    name = Column(Unicode(32), nullable=False)
-    description = Column(markdown.MarkdownColumn(128), nullable=False)
+    __singlename__ = 'move_flag_type'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description="A numeric ID"))
+    identifier = Column(Unicode(32), nullable=False,
+        info=dict(description="A short identifier for the flag", format='identifier'))
+    description = ProseColumn(markdown.MarkdownColumn(128), plural='descriptions', nullable=False,
+        info=dict(description="A short description of the flag", format='markdown'))
  
  
-class MoveFlavorText(TableBase):
+class MoveFlavorText(TableBase, LanguageSpecific):
+    u"""In-game description of a move
+    """
      __tablename__ = 'move_flavor_text'
      __tablename__ = 'move_flavor_text'
+    move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description="ID of the move"))
+    version_group_id = Column(Integer, ForeignKey('version_groups.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description="ID of the version group this text appears in"))
+    flavor_text = Column(Unicode(255), nullable=False,
+        info=dict(description="The flavor text", official=True, format='gametext'))
+
+class MoveMeta(TableBase):
+    u"""Metadata for move effects, sorta-kinda ripped straight from the game"""
+    __tablename__ = 'move_meta'
      move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False, autoincrement=False)
      move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False, autoincrement=False)
-    version_group_id = Column(Integer, ForeignKey('version_groups.id'), primary_key=True, nullable=False, autoincrement=False)
-    flavor_text = Column(Unicode(255), nullable=False)
+    meta_category_id = Column(Integer, ForeignKey('move_meta_categories.id'), nullable=False)
+    meta_ailment_id = Column(Integer, ForeignKey('move_meta_ailments.id'), nullable=False)
+    min_hits = Column(Integer, nullable=True, index=True)
+    max_hits = Column(Integer, nullable=True, index=True)
+    min_turns = Column(Integer, nullable=True, index=True)
+    max_turns = Column(Integer, nullable=True, index=True)
+    recoil = Column(Integer, nullable=False, index=True)
+    healing = Column(Integer, nullable=False, index=True)
+    crit_rate = Column(Integer, nullable=False, index=True)
+    ailment_chance = Column(Integer, nullable=False, index=True)
+    flinch_chance = Column(Integer, nullable=False, index=True)
+    stat_chance = Column(Integer, nullable=False, index=True)
+
+class MoveMetaAilment(TableBase, OfficiallyNamed):
+    u"""Common status ailments moves can inflict on a single Pokémon, including
+    major ailments like paralysis and minor ailments like trapping.
+    """
+    __tablename__ = 'move_meta_ailments'
+    __singlename__ = 'move_meta_ailment'
+    id = Column(Integer, primary_key=True, nullable=False)
+    identifier = Column(Unicode(24), nullable=False)
+
+class MoveMetaCategory(TableBase):
+    u"""Very general categories that loosely group move effects."""
+    __tablename__ = 'move_meta_categories'
+    __singlename__ = 'move_meta_category'
+    id = Column(Integer, primary_key=True, nullable=False)
+    description = ProseColumn(Unicode(64), plural='descriptions', nullable=False)
  
  
-class MoveName(TableBase):
-    __tablename__ = 'move_names'
+class MoveMetaStatChange(TableBase):
+    u"""Stat changes moves (may) make."""
+    __tablename__ = 'move_meta_stat_changes'
      move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False, autoincrement=False)
      move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False, autoincrement=False)
-    language_id = Column(Integer, ForeignKey('languages.id'), primary_key=True, nullable=False, autoincrement=False)
-    name = Column(Unicode(16), nullable=False)
+    stat_id = Column(Integer, ForeignKey('stats.id'), primary_key=True, nullable=False, autoincrement=False)
+    change = Column(Integer, nullable=False, index=True)
  
  
-class MoveTarget(TableBase):
+class MoveTarget(TableBase, UnofficiallyNamed):
+    u"""Targetting or "range" of a move, e.g. "Affects all opponents" or "Affects user".
+    """
      __tablename__ = 'move_targets'
      __tablename__ = 'move_targets'
-    id = Column(Integer, primary_key=True, nullable=False)
-    name = Column(Unicode(32), nullable=False)
-    description = Column(Unicode(128), nullable=False)
+    __singlename__ = 'move_target'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description="A numeric ID"))
+    identifier = Column(Unicode(32), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
+    description = ProseColumn(Unicode(128), plural='descriptions', nullable=False,
+        info=dict(description="A description", format='plaintext'))
  
  
-class Move(TableBase):
+class Move(TableBase, OfficiallyNamed):
+    u"""A Move: technique or attack a Pokémon can learn to use
+    """
      __tablename__ = 'moves'
      __singlename__ = 'move'
      __tablename__ = 'moves'
      __singlename__ = 'move'
-    id = Column(Integer, primary_key=True, nullable=False)
-    name = Column(Unicode(24), nullable=False)
-    generation_id = Column(Integer, ForeignKey('generations.id'), nullable=False)
-    type_id = Column(Integer, ForeignKey('types.id'), nullable=False)
-    power = Column(SmallInteger, nullable=False)
-    pp = Column(SmallInteger, nullable=False)
-    accuracy = Column(SmallInteger, nullable=True)
-    priority = Column(SmallInteger, nullable=False)
-    target_id = Column(Integer, ForeignKey('move_targets.id'), nullable=False)
-    damage_class_id = Column(Integer, ForeignKey('move_damage_classes.id'), nullable=False)
-    effect_id = Column(Integer, ForeignKey('move_effects.id'), nullable=False)
-    effect_chance = Column(Integer)
-    contest_type_id = Column(Integer, ForeignKey('contest_types.id'), nullable=True)
-    contest_effect_id = Column(Integer, ForeignKey('contest_effects.id'), nullable=True)
-    super_contest_effect_id = Column(Integer, ForeignKey('super_contest_effects.id'), nullable=True)
-
-class Nature(TableBase):
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description="A numeric ID"))
+    identifier = Column(Unicode(24), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
+    generation_id = Column(Integer, ForeignKey('generations.id'), nullable=False,
+        info=dict(description="ID of the generation this move first appeared in"))
+    type_id = Column(Integer, ForeignKey('types.id'), nullable=False,
+        info=dict(description="ID of the move's elemental type"))
+    power = Column(SmallInteger, nullable=False,
+        info=dict(description="Base power of the move"))
+    pp = Column(SmallInteger, nullable=True,
+        info=dict(description="Base PP (Power Points) of the move, nullable if not applicable (e.g. Struggle and Shadow moves)."))
+    accuracy = Column(SmallInteger, nullable=True,
+        info=dict(description="Accuracy of the move; NULL means it never misses"))
+    priority = Column(SmallInteger, nullable=False,
+        info=dict(description="The move's priority bracket"))
+    target_id = Column(Integer, ForeignKey('move_targets.id'), nullable=False,
+        info=dict(description="ID of the target (range) of the move"))
+    damage_class_id = Column(Integer, ForeignKey('move_damage_classes.id'), nullable=False,
+        info=dict(description="ID of the damage class (physical/special) of the move"))
+    effect_id = Column(Integer, ForeignKey('move_effects.id'), nullable=False,
+        info=dict(description="ID of the move's effect"))
+    effect_chance = Column(Integer, nullable=True,
+        info=dict(description="The chance for a secondary effect. What this is a chance of is specified by the move's effect."))
+    contest_type_id = Column(Integer, ForeignKey('contest_types.id'), nullable=True,
+        info=dict(description="ID of the move's Contest type (e.g. cool or smart)"))
+    contest_effect_id = Column(Integer, ForeignKey('contest_effects.id'), nullable=True,
+        info=dict(description="ID of the move's Contest effect"))
+    super_contest_effect_id = Column(Integer, ForeignKey('super_contest_effects.id'), nullable=True,
+        info=dict(description="ID of the move's Super Contest effect"))
+
+class MoveChangelog(TableBase):
+    """History of changes to moves across main game versions."""
+    __tablename__ = 'move_changelog'
+    __singlename__ = 'move_changelog'
+    move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False,
+        info=dict(description="ID of the move that changed"))
+    changed_in_version_group_id = Column(Integer, ForeignKey('version_groups.id'), primary_key=True, nullable=False,
+        info=dict(description="ID of the version group in which the move changed"))
+    type_id = Column(Integer, ForeignKey('types.id'), nullable=True,
+        info=dict(description="Prior type of the move, or NULL if unchanged"))
+    power = Column(SmallInteger, nullable=True,
+        info=dict(description="Prior base power of the move, or NULL if unchanged"))
+    pp = Column(SmallInteger, nullable=True,
+        info=dict(description="Prior base PP of the move, or NULL if unchanged"))
+    accuracy = Column(SmallInteger, nullable=True,
+        info=dict(description="Prior accuracy of the move, or NULL if unchanged"))
+    effect_id = Column(Integer, ForeignKey('move_effects.id'), nullable=True,
+        info=dict(description="Prior ID of the effect, or NULL if unchanged"))
+    effect_chance = Column(Integer, nullable=True,
+        info=dict(description="Prior effect chance, or NULL if unchanged"))
+
+class Nature(TableBase, OfficiallyNamed):
+    u"""A nature a Pokémon can have, such as Calm or Brave
+    """
      __tablename__ = 'natures'
      __singlename__ = 'nature'
      __tablename__ = 'natures'
      __singlename__ = 'nature'
-    id = Column(Integer, primary_key=True, nullable=False)
-    name = Column(Unicode(8), nullable=False)
-    decreased_stat_id = Column(Integer, ForeignKey('stats.id'), nullable=False)
-    increased_stat_id = Column(Integer, ForeignKey('stats.id'), nullable=False)
-    hates_flavor_id = Column(Integer, ForeignKey('contest_types.id'), nullable=False)
-    likes_flavor_id = Column(Integer, ForeignKey('contest_types.id'), nullable=False)
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description="A numeric ID"))
+    identifier = Column(Unicode(8), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
+    decreased_stat_id = Column(Integer, ForeignKey('stats.id'), nullable=False,
+        info=dict(description="ID of the stat that this nature decreases by 10% (if decreased_stat_id is the same, the effects cancel out)"))
+    increased_stat_id = Column(Integer, ForeignKey('stats.id'), nullable=False,
+        info=dict(description="ID of the stat that this nature increases by 10% (if decreased_stat_id is the same, the effects cancel out)"))
+    hates_flavor_id = Column(Integer, ForeignKey('contest_types.id'), nullable=False,
+        info=dict(description=u"ID of the Berry flavor the Pokémon hates (if likes_flavor_id is the same, the effects cancel out)"))
+    likes_flavor_id = Column(Integer, ForeignKey('contest_types.id'), nullable=False,
+        info=dict(description=u"ID of the Berry flavor the Pokémon likes (if hates_flavor_id is the same, the effects cancel out)"))
  
      @property
      def is_neutral(self):
  
      @property
      def is_neutral(self):
@@ -577,108 +829,149 @@ class Nature(TableBase):
          return self.increased_stat_id == self.decreased_stat_id
  
  class NatureBattleStylePreference(TableBase):
          return self.increased_stat_id == self.decreased_stat_id
  
  class NatureBattleStylePreference(TableBase):
-    __tablename__ = 'nature_battle_style_preferences'
-    nature_id = Column(Integer, ForeignKey('natures.id'), primary_key=True, nullable=False)
-    move_battle_style_id = Column(Integer, ForeignKey('move_battle_styles.id'), primary_key=True, nullable=False)
-    low_hp_preference = Column(Integer, nullable=False)
-    high_hp_preference = Column(Integer, nullable=False)
+    u"""Battle Palace move preference
  
  
-class NatureName(TableBase):
-    __tablename__ = 'nature_names'
-    nature_id = Column(Integer, ForeignKey('natures.id'), primary_key=True, nullable=False, autoincrement=False)
-    language_id = Column(Integer, ForeignKey('languages.id'), primary_key=True, nullable=False, autoincrement=False)
-    name = Column(Unicode(8), nullable=False)
+    Specifies how likely a Pokémon with a specific Nature is to use a move of
+    a particular battl style in Battle Palace or Battle Tent
+    """
+    __tablename__ = 'nature_battle_style_preferences'
+    nature_id = Column(Integer, ForeignKey('natures.id'), primary_key=True, nullable=False,
+        info=dict(description=u"ID of the Pokémon's nature"))
+    move_battle_style_id = Column(Integer, ForeignKey('move_battle_styles.id'), primary_key=True, nullable=False,
+        info=dict(description="ID of the battle style"))
+    low_hp_preference = Column(Integer, nullable=False,
+        info=dict(description=u"Chance of using the move, in percent, if HP is under ½"))
+    high_hp_preference = Column(Integer, nullable=False,
+        info=dict(description=u"Chance of using the move, in percent, if HP is over ½"))
  
  class NaturePokeathlonStat(TableBase):
  
  class NaturePokeathlonStat(TableBase):
+    u"""Specifies how a Nature affects a Pokéathlon stat
+    """
      __tablename__ = 'nature_pokeathlon_stats'
      __tablename__ = 'nature_pokeathlon_stats'
-    nature_id = Column(Integer, ForeignKey('natures.id'), primary_key=True, nullable=False)
-    pokeathlon_stat_id = Column(Integer, ForeignKey('pokeathlon_stats.id'), primary_key=True, nullable=False)
-    max_change = Column(Integer, nullable=False)
-
-class PokeathlonStat(TableBase):
+    nature_id = Column(Integer, ForeignKey('natures.id'), primary_key=True, nullable=False,
+        info=dict(description="ID of the nature"))
+    pokeathlon_stat_id = Column(Integer, ForeignKey('pokeathlon_stats.id'), primary_key=True, nullable=False,
+        info=dict(description="ID of the stat"))
+    max_change = Column(Integer, nullable=False,
+        info=dict(description="Maximum change"))
+
+class PokeathlonStat(TableBase, OfficiallyNamed):
+    u"""A Pokéathlon stat, such as "Stamina" or "Jump".
+    """
      __tablename__ = 'pokeathlon_stats'
      __tablename__ = 'pokeathlon_stats'
-    id = Column(Integer, primary_key=True, nullable=False)
-    name = Column(Unicode(8), nullable=False)
+    __singlename__ = 'pokeathlon_stat'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description="A numeric ID"))
+    identifier = Column(Unicode(8), nullable=False,
+        info=dict(description="An identifier", format='identifier'))
  
  
-class Pokedex(TableBase):
+class Pokedex(TableBase, UnofficiallyNamed):
+    u"""A collection of Pokémon species ordered in a particular way
+    """
      __tablename__ = 'pokedexes'
      __tablename__ = 'pokedexes'
-    id = Column(Integer, primary_key=True, nullable=False)
-    region_id = Column(Integer, ForeignKey('regions.id'), nullable=True)
-    name = Column(Unicode(16), nullable=False)
-    description = Column(Unicode(512))
-
-class PokedexVersionGroup(TableBase):
-    __tablename__ = 'pokedex_version_groups'
-    pokedex_id = Column(Integer, ForeignKey('pokedexes.id'), primary_key=True, nullable=False, autoincrement=False)
-    version_group_id = Column(Integer, ForeignKey('version_groups.id'), primary_key=True, nullable=False, autoincrement=False)
-
-class Pokemon(TableBase):
-    """The core to this whole mess.
+    __singlename__ = 'pokedex'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description="A numeric ID"))
+    region_id = Column(Integer, ForeignKey('regions.id'), nullable=True,
+        info=dict(description=u"ID of the region this Pokédex is used in, or None if it's global"))
+    identifier = Column(Unicode(16), nullable=False,
+        info=dict(description=u"An identifier", format='identifier'))
+    description = ProseColumn(Unicode(512), plural='descriptions', nullable=False,
+        info=dict(description=u"A longer description of the Pokédex", format='plaintext'))
  
  
-    Note that I use both 'forme' and 'form' in both code and the database.  I
-    only use 'forme' when specifically referring to Pokémon that have multiple
-    distinct species as forms—i.e., different stats or movesets.  'Form' is a
-    more general term referring to any variation within a species, including
-    purely cosmetic forms like Unown.
+class Pokemon(TableBase, OfficiallyNamed):
+    u"""A species of Pokémon.  The core to this whole mess.
      """
      __tablename__ = 'pokemon'
      __singlename__ = 'pokemon'
      """
      __tablename__ = 'pokemon'
      __singlename__ = 'pokemon'
-    id = Column(Integer, primary_key=True, nullable=False)
-    name = Column(Unicode(20), nullable=False)
-    forme_name = Column(Unicode(16))
-    forme_base_pokemon_id = Column(Integer, ForeignKey('pokemon.id'))
-    generation_id = Column(Integer, ForeignKey('generations.id'))
-    evolution_chain_id = Column(Integer, ForeignKey('evolution_chains.id'))
-    height = Column(Integer, nullable=False)
-    weight = Column(Integer, nullable=False)
-    species = Column(Unicode(16), nullable=False)
-    color_id = Column(Integer, ForeignKey('pokemon_colors.id'), nullable=False)
-    pokemon_shape_id = Column(Integer, ForeignKey('pokemon_shapes.id'), nullable=True)
-    habitat_id = Column(Integer, ForeignKey('pokemon_habitats.id'), nullable=True)
-    gender_rate = Column(Integer, nullable=False)
-    capture_rate = Column(Integer, nullable=False)
-    base_experience = Column(Integer, nullable=False)
-    base_happiness = Column(Integer, nullable=False)
-    is_baby = Column(Boolean, nullable=False)
-    hatch_counter = Column(Integer, nullable=False)
-    has_gen4_fem_sprite = Column(Boolean, nullable=False)
-    has_gen4_fem_back_sprite = Column(Boolean, nullable=False)
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description=u"A numeric ID"))
+    identifier = Column(Unicode(20), nullable=False,
+        info=dict(description=u"An identifier", format='identifier'))
+    generation_id = Column(Integer, ForeignKey('generations.id'),
+        info=dict(description=u"ID of the generation this species first appeared in"))
+    evolution_chain_id = Column(Integer, ForeignKey('evolution_chains.id'),
+        info=dict(description=u"ID of the species' evolution chain (a.k.a. family)"))
+    height = Column(Integer, nullable=False,
+        info=dict(description=u"The height of the Pokémon, in decimeters (tenths of a meter)"))
+    weight = Column(Integer, nullable=False,
+        info=dict(description=u"The weight of the Pokémon, in tenths of a kilogram (decigrams)"))
+    species = TextColumn(Unicode(16), nullable=False, plural='species_names',
+        info=dict(description=u'The short flavor text, such as "Seed" or "Lizard"; usually affixed with the word "Pokémon"',
+        official=True, format='plaintext'))
+    color_id = Column(Integer, ForeignKey('pokemon_colors.id'), nullable=False,
+        info=dict(description=u"ID of this Pokémon's Pokédex color, as used for a gimmick search function in the games."))
+    pokemon_shape_id = Column(Integer, ForeignKey('pokemon_shapes.id'), nullable=True,
+        info=dict(description=u"ID of this Pokémon's body shape, as used for a gimmick search function in the games."))
+    habitat_id = Column(Integer, ForeignKey('pokemon_habitats.id'), nullable=True,
+        info=dict(description=u"ID of this Pokémon's habitat, as used for a gimmick search function in the games."))
+    gender_rate = Column(Integer, nullable=False,
+        info=dict(description=u"The chance of this Pokémon being female, in eighths; or -1 for genderless"))
+    capture_rate = Column(Integer, nullable=False,
+        info=dict(description=u"The base capture rate; up to 255"))
+    base_experience = Column(Integer, nullable=False,
+        info=dict(description=u"The base EXP gained when defeating this Pokémon"))  # XXX: Is this correct?
+    base_happiness = Column(Integer, nullable=False,
+        info=dict(description=u"The tameness when caught by a normal ball"))
+    is_baby = Column(Boolean, nullable=False,
+        info=dict(description=u"True iff the Pokémon is a baby, i.e. a lowest-stage Pokémon that cannot breed but whose evolved form can."))
+    hatch_counter = Column(Integer, nullable=False,
+        info=dict(description=u"Initial hatch counter: one must walk 255 × (hatch_counter + 1) steps before this Pokémon's egg hatches, unless utilizing bonuses like Flame Body's"))
+    has_gender_differences = Column(Boolean, nullable=False,
+        info=dict(description=u"Set iff the species exhibits enough sexual dimorphism to have separate sets of sprites in Gen IV and beyond."))
+    order = Column(Integer, nullable=False, index=True,
+        info=dict(description=u"Order for sorting. Almost national order, except families and forms are grouped together."))
  
      ### Stuff to handle alternate Pokémon forms
  
      @property
  
      ### Stuff to handle alternate Pokémon forms
  
      @property
-    def national_id(self):
-        """Returns the National Pokédex number for this Pokémon.  Use this
-        instead of the id directly; alternate formes may make the id incorrect.
+    def form(self):
+        u"""Returns the Pokémon's form, using its default form as fallback."""
+
+        return self.unique_form or self.default_form
+
+    @property
+    def is_base_form(self):
+        u"""Returns True iff the Pokémon is the base form for its species,
+        e.g. Land Shaymin.
+        """
+
+        return self.unique_form is None or self.unique_form.is_default
+
+    @property
+    def form_name(self):
+        u"""Returns the Pokémon's form name if it represents a particular form
+        and that form has a name, or None otherwise.
          """
  
          """
  
-        if self.forme_base_pokemon_id:
-            return self.forme_base_pokemon_id
-        return self.id
+        # If self.unique_form is None, the short-circuit "and" will go ahead
+        # and return that.  Otherwise, it'll return the form's name, which may
+        # also be None.
+        return self.unique_form and self.unique_form.name
  
      @property
      def full_name(self):
  
      @property
      def full_name(self):
-        """Returns the name of this Pokémon, including its Forme, if any."""
+        u"""Returns the Pokémon's name, including its form if applicable."""
  
  
-        if self.forme_name:
-            return "%s %s" % (self.forme_name.title(), self.name)
-        return self.name
+        if self.form_name:
+            return u'{0} {1}'.format(self.form_name, self.name)
+        else:
+            return self.name
  
      @property
      def normal_form(self):
  
      @property
      def normal_form(self):
-        """Returns the normal form for this Pokémon; i.e., this will return
+        u"""Returns the normal form for this Pokémon; i.e., this will return
          regular Deoxys when called on any Deoxys form.
          """
  
          regular Deoxys when called on any Deoxys form.
          """
  
-        if self.forme_base_pokemon:
-            return self.forme_base_pokemon
-
+        if self.unique_form:
+            return self.unique_form.form_base_pokemon
          return self
  
      ### Not forms!
  
      def stat(self, stat_name):
          return self
  
      ### Not forms!
  
      def stat(self, stat_name):
-        """Returns a PokemonStat record for the given stat name (or Stat row
+        u"""Returns a PokemonStat record for the given stat name (or Stat row
          object).  Uses the normal has-many machinery, so all the stats are
          effectively cached.
          """
          object).  Uses the normal has-many machinery, so all the stats are
          effectively cached.
          """
@@ -712,196 +1005,430 @@ class Pokemon(TableBase):
              return None
  
  class PokemonAbility(TableBase):
              return None
  
  class PokemonAbility(TableBase):
+    u"""Maps an ability to a Pokémon that can have it
+    """
      __tablename__ = 'pokemon_abilities'
      __tablename__ = 'pokemon_abilities'
-    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False)
-    ability_id = Column(Integer, ForeignKey('abilities.id'), nullable=False)
-    slot = Column(Integer, primary_key=True, nullable=False, autoincrement=False)
-
-class PokemonColor(TableBase):
+    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"ID of the Pokémon"))
+    ability_id = Column(Integer, ForeignKey('abilities.id'), nullable=False,
+        info=dict(description=u"ID of the ability"))
+    # XXX having both a method and a slot is kind of gross.  "slot" is a
+    # misnomer, anyway: duplicate abilities don't appear in slot 2.
+    # Probably should replace that with "order".
+    is_dream = Column(Boolean, nullable=False, index=True,
+        info=dict(description=u"Whether this is a Dream World ability"))
+    slot = Column(Integer, primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"The ability slot, i.e. 1 or 2 for gen. IV"))
+
+class PokemonColor(TableBase, OfficiallyNamed):
+    u"""The "Pokédex color" of a Pokémon species. Usually based on the Pokémon's color.
+    """
      __tablename__ = 'pokemon_colors'
      __tablename__ = 'pokemon_colors'
-    id = Column(Integer, primary_key=True, nullable=False, autoincrement=False)
-    name = Column(Unicode(6), nullable=False)
+    __singlename__ = 'pokemon_color'
+    id = Column(Integer, primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"ID of the Pokémon"))
+    identifier = Column(Unicode(6), nullable=False,
+        info=dict(description=u"An identifier", format='identifier'))
  
  class PokemonDexNumber(TableBase):
  
  class PokemonDexNumber(TableBase):
+    u"""The number of a Pokémon in a particular Pokédex (e.g. Jigglypuff is #138 in Hoenn's 'dex)
+    """
      __tablename__ = 'pokemon_dex_numbers'
      __tablename__ = 'pokemon_dex_numbers'
-    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False)
-    pokedex_id = Column(Integer, ForeignKey('pokedexes.id'), primary_key=True, nullable=False, autoincrement=False)
-    pokedex_number = Column(Integer, nullable=False)
+    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"ID of the Pokémon"))
+    pokedex_id = Column(Integer, ForeignKey('pokedexes.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"ID of the Pokédex"))
+    pokedex_number = Column(Integer, nullable=False,
+        info=dict(description=u"Number of the Pokémon in that the Pokédex"))
  
  class PokemonEggGroup(TableBase):
  
  class PokemonEggGroup(TableBase):
+    u"""Maps an Egg group to a Pokémon; each Pokémon belongs to one or two egg groups
+    """
      __tablename__ = 'pokemon_egg_groups'
      __tablename__ = 'pokemon_egg_groups'
-    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False)
-    egg_group_id = Column(Integer, ForeignKey('egg_groups.id'), primary_key=True, nullable=False, autoincrement=False)
+    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"ID of the Pokémon"))
+    egg_group_id = Column(Integer, ForeignKey('egg_groups.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"ID of the egg group"))
  
  class PokemonEvolution(TableBase):
  
  class PokemonEvolution(TableBase):
+    u"""A required action ("trigger") and the conditions under which the trigger
+    must occur to cause a Pokémon to evolve.
+
+    Any condition may be null if it does not apply for a particular Pokémon.
+    """
      __tablename__ = 'pokemon_evolution'
      __tablename__ = 'pokemon_evolution'
-    from_pokemon_id = Column(Integer, ForeignKey('pokemon.id'), nullable=False)
-    to_pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False)
-    evolution_trigger_id = Column(Integer, ForeignKey('evolution_triggers.id'), nullable=False)
-    trigger_item_id = Column(Integer, ForeignKey('items.id'), nullable=True)
-    minimum_level = Column(Integer, nullable=True)
-    gender = Column(Enum('male', 'female', name='pokemon_evolution_gender'), nullable=True)
-    location_id = Column(Integer, ForeignKey('locations.id'), nullable=True)
-    held_item_id = Column(Integer, ForeignKey('items.id'), nullable=True)
-    time_of_day = Column(Enum('morning', 'day', 'night', name='pokemon_evolution_time_of_day'), nullable=True)
-    known_move_id = Column(Integer, ForeignKey('moves.id'), nullable=True)
-    minimum_happiness = Column(Integer, nullable=True)
-    minimum_beauty = Column(Integer, nullable=True)
-    relative_physical_stats = Column(Integer, nullable=True)
-    party_pokemon_id = Column(Integer, ForeignKey('pokemon.id'), nullable=True)
-
-class PokemonFlavorText(TableBase):
+    from_pokemon_id = Column(Integer, ForeignKey('pokemon.id'), nullable=False,
+        info=dict(description=u"The ID of the pre-evolution Pokémon."))
+    to_pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"The ID of the post-evolution Pokémon."))
+    evolution_trigger_id = Column(Integer, ForeignKey('evolution_triggers.id'), nullable=False,
+        info=dict(description=u"The ID of the evolution trigger."))
+    trigger_item_id = Column(Integer, ForeignKey('items.id'), nullable=True,
+        info=dict(description=u"The ID of the item that must be used on the Pokémon."))
+    minimum_level = Column(Integer, nullable=True,
+        info=dict(description=u"The minimum level for the Pokémon."))
+    gender = Column(Enum('male', 'female', name='pokemon_evolution_gender'), nullable=True,
+        info=dict(description=u"The Pokémon's required gender, or None if gender doesn't matter"))
+    location_id = Column(Integer, ForeignKey('locations.id'), nullable=True,
+        info=dict(description=u"The ID of the location the evolution must be triggered at."))
+    held_item_id = Column(Integer, ForeignKey('items.id'), nullable=True,
+        info=dict(description=u"The ID of the item the Pokémon must hold."))
+    time_of_day = Column(Enum('day', 'night', name='pokemon_evolution_time_of_day'), nullable=True,
+        info=dict(description=u"The required time of day."))
+    known_move_id = Column(Integer, ForeignKey('moves.id'), nullable=True,
+        info=dict(description=u"The ID of the move the Pokémon must know."))
+    minimum_happiness = Column(Integer, nullable=True,
+        info=dict(description=u"The minimum happiness value the Pokémon must have."))
+    minimum_beauty = Column(Integer, nullable=True,
+        info=dict(description=u"The minimum Beauty value the Pokémon must have."))
+    relative_physical_stats = Column(Integer, nullable=True,
+        info=dict(description=u"The required relation between the Pokémon's Attack and Defense stats, as sgn(atk-def)."))
+    party_pokemon_id = Column(Integer, ForeignKey('pokemon.id'), nullable=True,
+        info=dict(description=u"The ID of the Pokémon that must be present in the party."))
+    trade_pokemon_id = Column(Integer, ForeignKey('pokemon.id'), nullable=True,
+        info=dict(description=u"The ID of the Pokémon for which this Pokémon must be traded."))
+
+class PokemonFlavorText(TableBase, LanguageSpecific):
+    u"""In-game Pokédex descrption of a Pokémon.
+    """
      __tablename__ = 'pokemon_flavor_text'
      __tablename__ = 'pokemon_flavor_text'
-    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False)
-    version_id = Column(Integer, ForeignKey('versions.id'), primary_key=True, nullable=False, autoincrement=False)
-    flavor_text = Column(Unicode(255), nullable=False)
+    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"ID of the Pokémon"))
+    version_id = Column(Integer, ForeignKey('versions.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"ID of the version that has this flavor text"))
+    flavor_text = Column(Unicode(255), nullable=False,
+        info=dict(description=u"ID of the version that has this flavor text", official=True, format='gametext'))
  
  
-class PokemonFormGroup(TableBase):
-    __tablename__ = 'pokemon_form_groups'
-    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False)
-    is_battle_only = Column(Boolean, nullable=False)
-    description = Column(markdown.MarkdownColumn(1024), nullable=False)
+class PokemonForm(TableBase, OfficiallyNamed):
+    u"""An individual form of a Pokémon.
  
  
-class PokemonFormSprite(TableBase):
-    __tablename__ = 'pokemon_form_sprites'
-    id = Column(Integer, primary_key=True, nullable=False)
-    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False)
-    introduced_in_version_group_id = Column(Integer, ForeignKey('version_groups.id'), primary_key=True, nullable=False, autoincrement=False)
-    name = Column(Unicode(16), nullable=True)
-    is_default = Column(Boolean, nullable=True)
+    Pokémon that do not have separate forms are still given a single row to
+    represent their single form.
+    """
+    __tablename__ = 'pokemon_forms'
+    __singlename__ = 'pokemon_form'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description=u'A unique ID for this form.'))
+    identifier = Column(Unicode(16), nullable=True,
+        info=dict(description=u"An identifier", format='identifier'))
+    form_base_pokemon_id = Column(Integer, ForeignKey('pokemon.id'), nullable=False, autoincrement=False,
+        info=dict(description=u'The ID of the base Pokémon for this form.'))
+    unique_pokemon_id = Column(Integer, ForeignKey('pokemon.id'), autoincrement=False,
+        info=dict(description=u'The ID of a Pokémon that represents specifically this form, for Pokémon with functionally-different forms like Wormadam.'))
+    introduced_in_version_group_id = Column(Integer, ForeignKey('version_groups.id'), autoincrement=False,
+        info=dict(description=u'The ID of the version group in which this form first appeared.'))
+    is_default = Column(Boolean, nullable=False,
+        info=dict(description=u'Set for exactly one form used as the default for each species.'))
+    order = Column(Integer, nullable=False, autoincrement=False,
+        info=dict(description=u'The order in which forms should be sorted.  Multiple forms may have equal order, in which case they should fall back on sorting by name.'))
  
  
-class PokemonHabitat(TableBase):
+    @property
+    def pokemon(self):
+        u"""Returns the Pokémon for this form, using the form base as fallback.
+        """
+
+        return self.unique_pokemon or self.form_base_pokemon
+
+    @property
+    def full_name(self):
+        u"""Returns the full name of this form, e.g. "Plant Cloak"."""
+
+        if not self.name:
+            return None
+        elif self.form_group and self.form_group.term:
+            return u'{0} {1}'.format(self.name, self.form_group.term)
+        else:
+            return self.name
+
+    @property
+    def pokemon_name(self):
+        u"""Returns the name of this Pokémon with this form, e.g. "Plant
+        Burmy".
+        """
+
+        if self.name:
+            return u'{0} {1}'.format(self.name, self.form_base_pokemon.name)
+        else:
+            return self.form_base_pokemon.name
+
+class PokemonFormGroup(TableBase):
+    u"""Information about a Pokémon's forms as a group."""
+    __tablename__ = 'pokemon_form_groups'
+    __singlename__ = 'pokemon_form_group'
+    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"ID of the base form Pokémon"))
+    term = ProseColumn(Unicode(16), plural='terms', nullable=True,
+        info=dict(description=u"The term for this Pokémon's forms, e.g. \"Cloak\" for Burmy or \"Forme\" for Deoxys.", official=True, format='plaintext'))
+    is_battle_only = Column(Boolean, nullable=False,
+        info=dict(description=u"Set iff the forms only change in battle"))
+    description = ProseColumn(markdown.MarkdownColumn(1024), plural='descriptions', nullable=False,
+        info=dict(description=u"Description of how the forms work", format='markdown'))
+PokemonFormGroup.id = PokemonFormGroup.pokemon_id
+
+class PokemonFormPokeathlonStat(TableBase):
+    u"""A Pokémon form's performance in one Pokéathlon stat."""
+    __tablename__ = 'pokemon_form_pokeathlon_stats'
+    pokemon_form_id = Column(Integer, ForeignKey('pokemon_forms.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u'The ID of the Pokémon form.'))
+    pokeathlon_stat_id = Column(Integer, ForeignKey('pokeathlon_stats.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u'The ID of the Pokéathlon stat.'))
+    minimum_stat = Column(Integer, nullable=False, autoincrement=False,
+        info=dict(description=u'The minimum value for this stat for this Pokémon form.'))
+    base_stat = Column(Integer, nullable=False, autoincrement=False,
+        info=dict(description=u'The default value for this stat for this Pokémon form.'))
+    maximum_stat = Column(Integer, nullable=False, autoincrement=False,
+        info=dict(description=u'The maximum value for this stat for this Pokémon form.'))
+
+class PokemonHabitat(TableBase, OfficiallyNamed):
+    u"""The habitat of a Pokémon, as given in the FireRed/LeafGreen version Pokédex
+    """
      __tablename__ = 'pokemon_habitats'
      __tablename__ = 'pokemon_habitats'
-    id = Column(Integer, primary_key=True, nullable=False, autoincrement=False)
-    name = Column(Unicode(16), nullable=False)
+    __singlename__ = 'pokemon_habitat'
+    id = Column(Integer, primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"A numeric ID"))
+    identifier = Column(Unicode(16), nullable=False,
+        info=dict(description=u"An identifier", format='identifier'))
  
  class PokemonInternalID(TableBase):
  
  class PokemonInternalID(TableBase):
+    u"""The number of a Pokémon a game uses internally
+    """
      __tablename__ = 'pokemon_internal_ids'
      __tablename__ = 'pokemon_internal_ids'
-    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, autoincrement=False, nullable=False)
-    generation_id = Column(Integer, ForeignKey('generations.id'), primary_key=True, autoincrement=False, nullable=False)
-    internal_id = Column(Integer, nullable=False)
+    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, autoincrement=False, nullable=False,
+        info=dict(description=u"Database ID of the Pokémon"))
+    generation_id = Column(Integer, ForeignKey('generations.id'), primary_key=True, autoincrement=False, nullable=False,
+        info=dict(description=u"Database ID of the generation"))
+    internal_id = Column(Integer, nullable=False,
+        info=dict(description=u"Internal ID the generation's games use for the Pokémon"))
  
  class PokemonItem(TableBase):
  
  class PokemonItem(TableBase):
+    u"""Record of an item a Pokémon can hold in the wild
+    """
      __tablename__ = 'pokemon_items'
      __tablename__ = 'pokemon_items'
-    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False)
-    version_id = Column(Integer, ForeignKey('versions.id'), primary_key=True, nullable=False, autoincrement=False)
-    item_id = Column(Integer, ForeignKey('items.id'), primary_key=True, nullable=False, autoincrement=False)
-    rarity = Column(Integer, nullable=False)
+    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"ID of the Pokémon"))
+    version_id = Column(Integer, ForeignKey('versions.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"ID of the version this applies to"))
+    item_id = Column(Integer, ForeignKey('items.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"ID of the item"))
+    rarity = Column(Integer, nullable=False,
+        info=dict(description=u"Chance of the Pokémon holding the item, in percent"))
  
  class PokemonMove(TableBase):
  
  class PokemonMove(TableBase):
+    u"""Record of a move a Pokémon can learn
+    """
      __tablename__ = 'pokemon_moves'
      __tablename__ = 'pokemon_moves'
-    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), nullable=False, index=True)
-    version_group_id = Column(Integer, ForeignKey('version_groups.id'), nullable=False, index=True)
-    move_id = Column(Integer, ForeignKey('moves.id'), nullable=False, index=True)
-    pokemon_move_method_id = Column(Integer, ForeignKey('pokemon_move_methods.id'), nullable=False, index=True)
-    level = Column(Integer, nullable=True, index=True)
-    order = Column(Integer, nullable=True)
+    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), nullable=False, index=True,
+        info=dict(description=u"ID of the Pokémon"))
+    version_group_id = Column(Integer, ForeignKey('version_groups.id'), nullable=False, index=True,
+        info=dict(description=u"ID of the version group this applies to"))
+    move_id = Column(Integer, ForeignKey('moves.id'), nullable=False, index=True,
+        info=dict(description=u"ID of the move"))
+    pokemon_move_method_id = Column(Integer, ForeignKey('pokemon_move_methods.id'), nullable=False, index=True,
+        info=dict(description=u"ID of the method this move is learned by"))
+    level = Column(Integer, nullable=True, index=True,
+        info=dict(description=u"Level the move is learned at, if applicable"))
+    order = Column(Integer, nullable=True,
+        info=dict(description=u"A sort key to produce the correct ordering when all else is equal"))  # XXX: This needs a better description
  
      __table_args__ = (
          PrimaryKeyConstraint('pokemon_id', 'version_group_id', 'move_id', 'pokemon_move_method_id', 'level'),
          {},
      )
  
  
      __table_args__ = (
          PrimaryKeyConstraint('pokemon_id', 'version_group_id', 'move_id', 'pokemon_move_method_id', 'level'),
          {},
      )
  
-class PokemonMoveMethod(TableBase):
+class PokemonMoveMethod(TableBase, UnofficiallyNamed):
+    u"""A method a move can be learned by, such as "Level up" or "Tutor".
+    """
      __tablename__ = 'pokemon_move_methods'
      __tablename__ = 'pokemon_move_methods'
-    id = Column(Integer, primary_key=True, nullable=False, autoincrement=False)
-    name = Column(Unicode(64), nullable=False)
-    description = Column(Unicode(255), nullable=False)
-
-class PokemonName(TableBase):
-    __tablename__ = 'pokemon_names'
-    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False)
-    language_id = Column(Integer, ForeignKey('languages.id'), primary_key=True, nullable=False, autoincrement=False)
-    name = Column(Unicode(16), nullable=False)
-
-class PokemonShape(TableBase):
+    __singlename__ = 'pokemon_move_method'
+    id = Column(Integer, primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"A numeric ID"))
+    identifier = Column(Unicode(64), nullable=False,
+        info=dict(description=u"An identifier", format='identifier'))
+    description = ProseColumn(Unicode(255), plural='descriptions', nullable=False,
+        info=dict(description=u"A detailed description of how the method works", format='plaintext'))
+
+class PokemonShape(TableBase, UnofficiallyNamed):
+    u"""The shape of a Pokémon's body, as used in generation IV Pokédexes.
+    """
      __tablename__ = 'pokemon_shapes'
      __tablename__ = 'pokemon_shapes'
-    id = Column(Integer, primary_key=True, nullable=False)
-    name = Column(Unicode(24), nullable=False)
-    awesome_name = Column(Unicode(16), nullable=False)
+    __singlename__ = 'pokemon_shape'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description=u"A numeric ID"))
+    identifier = Column(Unicode(24), nullable=False,
+        info=dict(description=u"An identifier", format='identifier'))
+    awesome_name = ProseColumn(Unicode(16), plural='awesome_names', nullable=False,
+        info=dict(description=u"A splendiferous name of the body shape", format='plaintext'))
  
  class PokemonStat(TableBase):
  
  class PokemonStat(TableBase):
+    u"""A stat value of a Pokémon
+    """
      __tablename__ = 'pokemon_stats'
      __tablename__ = 'pokemon_stats'
-    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False)
-    stat_id = Column(Integer, ForeignKey('stats.id'), primary_key=True, nullable=False, autoincrement=False)
-    base_stat = Column(Integer, nullable=False)
-    effort = Column(Integer, nullable=False)
+    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"ID of the Pokémon"))
+    stat_id = Column(Integer, ForeignKey('stats.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"ID of the stat"))
+    base_stat = Column(Integer, nullable=False,
+        info=dict(description=u"The base stat"))
+    effort = Column(Integer, nullable=False,
+        info=dict(description=u"The effort increase in this stat gained when this Pokémon is defeated"))
  
  class PokemonType(TableBase):
  
  class PokemonType(TableBase):
+    u"""Maps a type to a Pokémon. Each Pokémon has 1 or 2 types.
+    """
      __tablename__ = 'pokemon_types'
      __tablename__ = 'pokemon_types'
-    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False)
-    type_id = Column(Integer, ForeignKey('types.id'), nullable=False)
-    slot = Column(Integer, primary_key=True, nullable=False, autoincrement=False)
-
-class Region(TableBase):
-    """Major areas of the world: Kanto, Johto, etc."""
+    pokemon_id = Column(Integer, ForeignKey('pokemon.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"ID of the Pokémon"))
+    type_id = Column(Integer, ForeignKey('types.id'), nullable=False,
+        info=dict(description=u"ID of the type"))
+    slot = Column(Integer, primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"The type's slot, 1 or 2, used to sort types if there are two of them"))
+
+class Region(TableBase, OfficiallyNamed):
+    u"""Major areas of the world: Kanto, Johto, etc.
+    """
      __tablename__ = 'regions'
      __tablename__ = 'regions'
-    id = Column(Integer, primary_key=True, nullable=False)
-    name = Column(Unicode(16), nullable=False)
+    __singlename__ = 'region'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description=u"A numeric ID"))
+    identifier = Column(Unicode(16), nullable=False,
+        info=dict(description=u"An identifier", format='identifier'))
  
  
-class Stat(TableBase):
+class Stat(TableBase, OfficiallyNamed):
+    u"""A Stat, such as Attack or Speed
+    """
      __tablename__ = 'stats'
      __tablename__ = 'stats'
+    __singlename__ = 'stat'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description=u"A numeric ID"))
+    damage_class_id = Column(Integer, ForeignKey('move_damage_classes.id'), nullable=True,
+        info=dict(description=u"For offensive and defensive stats, the damage this stat relates to; otherwise None (the NULL value)"))
+    identifier = Column(Unicode(16), nullable=False,
+        info=dict(description=u"An identifier", format='identifier'))
+
+class StatHint(TableBase):
+    u"""Flavor text for genes that appears in a Pokémon's summary.  Sometimes
+    called "characteristics".
+    """
+    __tablename__ = 'stat_hints'
+    __singlename__ = 'stat_hint'
      id = Column(Integer, primary_key=True, nullable=False)
      id = Column(Integer, primary_key=True, nullable=False)
-    damage_class_id = Column(Integer, ForeignKey('move_damage_classes.id'), nullable=True)
-    name = Column(Unicode(16), nullable=False)
+    stat_id = Column(Integer, ForeignKey('stats.id'), nullable=False)
+    gene_mod_5 = Column(Integer, nullable=False, index=True)
+    text = TextColumn(Unicode(24), plural='texts', nullable=False, index=True, unique=True,
+        info=dict(description=u"The English text displayed", official=True, format='plaintext'))
  
  class SuperContestCombo(TableBase):
  
  class SuperContestCombo(TableBase):
+    u"""Combo of two moves in a Super Contest.
+    """
      __tablename__ = 'super_contest_combos'
      __tablename__ = 'super_contest_combos'
-    first_move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False, autoincrement=False)
-    second_move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False, autoincrement=False)
+    first_move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"The ID of the first move in the combo."))
+    second_move_id = Column(Integer, ForeignKey('moves.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"The ID of the second and last move."))
  
  class SuperContestEffect(TableBase):
  
  class SuperContestEffect(TableBase):
+    u"""An effect a move can have when used in the Super Contest
+    """
      __tablename__ = 'super_contest_effects'
      __tablename__ = 'super_contest_effects'
-    id = Column(Integer, primary_key=True, nullable=False)
-    appeal = Column(SmallInteger, nullable=False)
-    flavor_text = Column(Unicode(64), nullable=False)
+    __singlename__ = 'super_contest_effect'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description=u"This effect's unique ID."))
+    appeal = Column(SmallInteger, nullable=False,
+        info=dict(description=u"The number of hearts the user gains."))
+    flavor_text = ProseColumn(Unicode(64), plural='flavor_texts', nullable=False,
+        info=dict(description=u"A description of the effect.", format='plaintext'))
  
  class TypeEfficacy(TableBase):
  
  class TypeEfficacy(TableBase):
+    u"""The damage multiplier used when a move of a particular type damages a
+    Pokémon of a particular other type.
+    """
      __tablename__ = 'type_efficacy'
      __tablename__ = 'type_efficacy'
-    damage_type_id = Column(Integer, ForeignKey('types.id'), primary_key=True, nullable=False, autoincrement=False)
-    target_type_id = Column(Integer, ForeignKey('types.id'), primary_key=True, nullable=False, autoincrement=False)
-    damage_factor = Column(Integer, nullable=False)
-
-class Type(TableBase):
+    damage_type_id = Column(Integer, ForeignKey('types.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"The ID of the damaging type."))
+    target_type_id = Column(Integer, ForeignKey('types.id'), primary_key=True, nullable=False, autoincrement=False,
+        info=dict(description=u"The ID of the defending Pokémon's type."))
+    damage_factor = Column(Integer, nullable=False,
+        info=dict(description=u"The multiplier, as a percentage of damage inflicted."))
+
+class Type(TableBase, OfficiallyNamed):
+    u"""Any of the elemental types Pokémon and moves can have."""
      __tablename__ = 'types'
      __singlename__ = 'type'
      __tablename__ = 'types'
      __singlename__ = 'type'
-    id = Column(Integer, primary_key=True, nullable=False)
-    name = Column(Unicode(8), nullable=False)
-    abbreviation = Column(Unicode(3), nullable=False)
-    generation_id = Column(Integer, ForeignKey('generations.id'), nullable=False)
-    damage_class_id = Column(Integer, ForeignKey('move_damage_classes.id'), nullable=False) ## ??? is none; everything else is physical or special
-
-class TypeName(TableBase):
-    __tablename__ = 'type_names'
-    type_id = Column(Integer, ForeignKey('types.id'), primary_key=True, nullable=False, autoincrement=False)
-    language_id = Column(Integer, ForeignKey('languages.id'), primary_key=True, nullable=False, autoincrement=False)
-    name = Column(Unicode(16), nullable=False)
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description=u"A unique ID for this type."))
+    identifier = Column(Unicode(8), nullable=False,
+        info=dict(description=u"An identifier", format='identifier'))
+    generation_id = Column(Integer, ForeignKey('generations.id'), nullable=False,
+        info=dict(description=u"The ID of the generation this type first appeared in."))
+    damage_class_id = Column(Integer, ForeignKey('move_damage_classes.id'), nullable=True,
+        info=dict(description=u"The ID of the damage class this type's moves had before Generation IV, null if not applicable (e.g. ???)."))
  
  class VersionGroup(TableBase):
  
  class VersionGroup(TableBase):
+    u"""A group of versions, containing either two paired versions (such as Red
+    and Blue) or a single game (such as Yellow.)
+    """
      __tablename__ = 'version_groups'
      __tablename__ = 'version_groups'
-    id = Column(Integer, primary_key=True, nullable=False)
-    generation_id = Column(Integer, ForeignKey('generations.id'), nullable=False)
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description=u"This version group's unique ID."))
+    generation_id = Column(Integer, ForeignKey('generations.id'), nullable=False,
+        info=dict(description=u"The ID of the generation the games in this group belong to."))
+    pokedex_id = Column(Integer, ForeignKey('pokedexes.id'), nullable=False,
+        info=dict(description=u"The ID of the regional Pokédex used in this version group."))
  
  class VersionGroupRegion(TableBase):
  
  class VersionGroupRegion(TableBase):
+    u"""Maps a version group to a region that appears in it."""
      __tablename__ = 'version_group_regions'
      __tablename__ = 'version_group_regions'
-    version_group_id = Column(Integer, ForeignKey('version_groups.id'), primary_key=True, nullable=False)
-    region_id = Column(Integer, ForeignKey('regions.id'), primary_key=True, nullable=False)
+    version_group_id = Column(Integer, ForeignKey('version_groups.id'), primary_key=True, nullable=False,
+        info=dict(description=u"The ID of the version group."))
+    region_id = Column(Integer, ForeignKey('regions.id'), primary_key=True, nullable=False,
+        info=dict(description=u"The ID of the region."))
  
  
-class Version(TableBase):
+class Version(TableBase, OfficiallyNamed):
+    u"""An individual main-series Pokémon game."""
      __tablename__ = 'versions'
      __tablename__ = 'versions'
-    id = Column(Integer, primary_key=True, nullable=False)
-    version_group_id = Column(Integer, ForeignKey('version_groups.id'), nullable=False)
-    name = Column(Unicode(32), nullable=False)
+    __singlename__ = 'version'
+    id = Column(Integer, primary_key=True, nullable=False,
+        info=dict(description=u"A unique ID for this version."))
+    version_group_id = Column(Integer, ForeignKey('version_groups.id'), nullable=False,
+        info=dict(description=u"The ID of the version group this game belongs to."))
+    identifier = Column(Unicode(32), nullable=False,
+        info=dict(description=u'And identifier', format='identifier'))
  
  
  ### Relations down here, to avoid ordering problems
  
  
  ### Relations down here, to avoid ordering problems
+Ability.changelog = relation(AbilityChangelog,
+    order_by=AbilityChangelog.changed_in_version_group_id.desc(),
+    backref='ability',
+)
  Ability.flavor_text = relation(AbilityFlavorText, order_by=AbilityFlavorText.version_group_id, backref='ability')
  Ability.flavor_text = relation(AbilityFlavorText, order_by=AbilityFlavorText.version_group_id, backref='ability')
-Ability.foreign_names = relation(AbilityName, backref='ability')
  Ability.generation = relation(Generation, backref='abilities')
  Ability.generation = relation(Generation, backref='abilities')
+Ability.all_pokemon = relation(Pokemon,
+    secondary=PokemonAbility.__table__,
+    order_by=Pokemon.order,
+    back_populates='all_abilities',
+)
+Ability.pokemon = relation(Pokemon,
+    secondary=PokemonAbility.__table__,
+    primaryjoin=and_(
+        PokemonAbility.ability_id == Ability.id,
+        PokemonAbility.is_dream == False
+    ),
+    order_by=Pokemon.order,
+    back_populates='abilities',
+)
+Ability.dream_pokemon = relation(Pokemon,
+    secondary=PokemonAbility.__table__,
+    primaryjoin=and_(
+        PokemonAbility.ability_id == Ability.id,
+        PokemonAbility.is_dream == True
+    ),
+    order_by=Pokemon.order,
+    back_populates='dream_ability',
+)
  
  
-AbilityFlavorText.version_group = relation(VersionGroup)
+AbilityChangelog.changed_in = relation(VersionGroup, backref='ability_changelog')
  
  
-AbilityName.language = relation(Language)
+AbilityFlavorText.version_group = relation(VersionGroup)
  
  Berry.berry_firmness = relation(BerryFirmness, backref='berries')
  Berry.firmness = association_proxy('berry_firmness', 'name')
  
  Berry.berry_firmness = relation(BerryFirmness, backref='berries')
  Berry.firmness = association_proxy('berry_firmness', 'name')
@@ -928,14 +1455,11 @@ EncounterConditionValueMap.condition_value = relation(EncounterConditionValue,
                                                        backref='encounter_map')
  
  EncounterSlot.terrain = relation(EncounterTerrain, backref='slots')
                                                        backref='encounter_map')
  
  EncounterSlot.terrain = relation(EncounterTerrain, backref='slots')
-
-EncounterSlot.condition_map = relation(EncounterSlotCondition, backref='slot')
-EncounterSlot.conditions = association_proxy('condition_map', 'condition')
-EncounterSlotCondition.condition = relation(EncounterCondition,
-                                            backref='slot_map')
+EncounterSlot.version_group = relation(VersionGroup)
  
  EvolutionChain.growth_rate = relation(GrowthRate, backref='evolution_chains')
  EvolutionChain.baby_trigger_item = relation(Item, backref='evolution_chains')
  
  EvolutionChain.growth_rate = relation(GrowthRate, backref='evolution_chains')
  EvolutionChain.baby_trigger_item = relation(Item, backref='evolution_chains')
+EvolutionChain.pokemon = relation(Pokemon, order_by=Pokemon.order, back_populates='evolution_chain')
  
  Experience.growth_rate = relation(GrowthRate, backref='experience_table')
  
  
  Experience.growth_rate = relation(GrowthRate, backref='experience_table')
  
@@ -950,12 +1474,11 @@ Item.berry = relation(Berry, uselist=False, backref='item')
  Item.flags = relation(ItemFlag, secondary=ItemFlagMap.__table__)
  Item.flavor_text = relation(ItemFlavorText, order_by=ItemFlavorText.version_group_id.asc(), backref='item')
  Item.fling_effect = relation(ItemFlingEffect, backref='items')
  Item.flags = relation(ItemFlag, secondary=ItemFlagMap.__table__)
  Item.flavor_text = relation(ItemFlavorText, order_by=ItemFlavorText.version_group_id.asc(), backref='item')
  Item.fling_effect = relation(ItemFlingEffect, backref='items')
-Item.foreign_names = relation(ItemName, backref='item')
  Item.machines = relation(Machine, order_by=Machine.version_group_id.asc())
  Item.category = relation(ItemCategory)
  Item.pocket = association_proxy('category', 'pocket')
  
  Item.machines = relation(Machine, order_by=Machine.version_group_id.asc())
  Item.category = relation(ItemCategory)
  Item.pocket = association_proxy('category', 'pocket')
  
-ItemCategory.items = relation(Item, order_by=Item.name)
+ItemCategory.items = relation(Item, order_by=Item.identifier)
  ItemCategory.pocket = relation(ItemPocket)
  
  ItemFlavorText.version_group = relation(VersionGroup)
  ItemCategory.pocket = relation(ItemPocket)
  
  ItemFlavorText.version_group = relation(VersionGroup)
@@ -963,9 +1486,7 @@ ItemFlavorText.version_group = relation(VersionGroup)
  ItemInternalID.item = relation(Item, backref='internal_ids')
  ItemInternalID.generation = relation(Generation)
  
  ItemInternalID.item = relation(Item, backref='internal_ids')
  ItemInternalID.generation = relation(Generation)
  
-ItemName.language = relation(Language)
-
-ItemPocket.categories = relation(ItemCategory, order_by=ItemCategory.name)
+ItemPocket.categories = relation(ItemCategory, order_by=ItemCategory.identifier)
  
  Location.region = relation(Region, backref='locations')
  
  
  Location.region = relation(Region, backref='locations')
  
@@ -977,6 +1498,10 @@ LocationInternalID.generation = relation(Generation)
  Machine.item = relation(Item)
  Machine.version_group = relation(VersionGroup)
  
  Machine.item = relation(Item)
  Machine.version_group = relation(VersionGroup)
  
+Move.changelog = relation(MoveChangelog,
+    order_by=MoveChangelog.changed_in_version_group_id.desc(),
+    backref='move',
+)
  Move.contest_effect = relation(ContestEffect, backref='moves')
  Move.contest_combo_next = association_proxy('contest_combo_first', 'second')
  Move.contest_combo_prev = association_proxy('contest_combo_second', 'first')
  Move.contest_effect = relation(ContestEffect, backref='moves')
  Move.contest_combo_next = association_proxy('contest_combo_first', 'second')
  Move.contest_combo_prev = association_proxy('contest_combo_second', 'first')
@@ -984,31 +1509,51 @@ Move.contest_type = relation(ContestType, backref='moves')
  Move.damage_class = relation(MoveDamageClass, backref='moves')
  Move.flags = association_proxy('move_flags', 'flag')
  Move.flavor_text = relation(MoveFlavorText, order_by=MoveFlavorText.version_group_id, backref='move')
  Move.damage_class = relation(MoveDamageClass, backref='moves')
  Move.flags = association_proxy('move_flags', 'flag')
  Move.flavor_text = relation(MoveFlavorText, order_by=MoveFlavorText.version_group_id, backref='move')
-Move.foreign_names = relation(MoveName, backref='move')
  Move.generation = relation(Generation, backref='moves')
  Move.machines = relation(Machine, backref='move')
  Move.generation = relation(Generation, backref='moves')
  Move.machines = relation(Machine, backref='move')
+Move.meta = relation(MoveMeta, uselist=False, backref='move')
+Move.meta_stat_changes = relation(MoveMetaStatChange)
  Move.move_effect = relation(MoveEffect, backref='moves')
  Move.move_flags = relation(MoveFlag, backref='move')
  Move.super_contest_effect = relation(SuperContestEffect, backref='moves')
  Move.super_contest_combo_next = association_proxy('super_contest_combo_first', 'second')
  Move.super_contest_combo_prev = association_proxy('super_contest_combo_second', 'first')
  Move.target = relation(MoveTarget, backref='moves')
  Move.move_effect = relation(MoveEffect, backref='moves')
  Move.move_flags = relation(MoveFlag, backref='move')
  Move.super_contest_effect = relation(SuperContestEffect, backref='moves')
  Move.super_contest_combo_next = association_proxy('super_contest_combo_first', 'second')
  Move.super_contest_combo_prev = association_proxy('super_contest_combo_second', 'first')
  Move.target = relation(MoveTarget, backref='moves')
-Move.type = relation(Type, backref='moves')
+Move.type = relation(Type, back_populates='moves')
  
  Move.effect = markdown.MoveEffectProperty('effect')
  
  Move.effect = markdown.MoveEffectProperty('effect')
+Move.effects = markdown.MoveEffectsProperty('effect')
  Move.short_effect = markdown.MoveEffectProperty('short_effect')
  Move.short_effect = markdown.MoveEffectProperty('short_effect')
+Move.short_effects = markdown.MoveEffectsProperty('short_effect')
+
+MoveChangelog.changed_in = relation(VersionGroup, backref='move_changelog')
+MoveChangelog.move_effect = relation(MoveEffect, backref='move_changelog')
+MoveChangelog.type = relation(Type, backref='move_changelog')
+
+MoveChangelog.effect = markdown.MoveEffectProperty('effect')
+MoveChangelog.effects = markdown.MoveEffectsProperty('effect')
+MoveChangelog.short_effect = markdown.MoveEffectProperty('short_effect')
+MoveChangelog.short_effects = markdown.MoveEffectsProperty('short_effect')
  
  MoveEffect.category_map = relation(MoveEffectCategoryMap)
  MoveEffect.categories = association_proxy('category_map', 'category')
  
  MoveEffect.category_map = relation(MoveEffectCategoryMap)
  MoveEffect.categories = association_proxy('category_map', 'category')
+MoveEffect.changelog = relation(MoveEffectChangelog,
+    order_by=MoveEffectChangelog.changed_in_version_group_id.desc(),
+    backref='move_effect',
+)
  MoveEffectCategoryMap.category = relation(MoveEffectCategory)
  
  MoveEffectCategoryMap.category = relation(MoveEffectCategory)
  
+MoveEffectChangelog.changed_in = relation(VersionGroup, backref='move_effect_changelog')
+
  MoveFlag.flag = relation(MoveFlagType)
  
  MoveFlavorText.version_group = relation(VersionGroup)
  
  MoveFlag.flag = relation(MoveFlagType)
  
  MoveFlavorText.version_group = relation(VersionGroup)
  
-MoveName.language = relation(Language)
+MoveMeta.category = relation(MoveMetaCategory, backref='move_meta')
+MoveMeta.ailment = relation(MoveMetaAilment, backref='move_meta')
+
+MoveMetaStatChange.stat = relation(Stat, backref='move_meta_stat_changes')
  
  
-Nature.foreign_names = relation(NatureName, backref='nature')
  Nature.decreased_stat = relation(Stat, primaryjoin=Nature.decreased_stat_id==Stat.id,
                                         backref='decreasing_natures')
  Nature.increased_stat = relation(Stat, primaryjoin=Nature.increased_stat_id==Stat.id,
  Nature.decreased_stat = relation(Stat, primaryjoin=Nature.decreased_stat_id==Stat.id,
                                         backref='decreasing_natures')
  Nature.increased_stat = relation(Stat, primaryjoin=Nature.increased_stat_id==Stat.id,
@@ -1024,32 +1569,38 @@ Nature.pokeathlon_effects = relation(NaturePokeathlonStat, order_by=NaturePokeat
  
  NatureBattleStylePreference.battle_style = relation(MoveBattleStyle, backref='nature_preferences')
  
  
  NatureBattleStylePreference.battle_style = relation(MoveBattleStyle, backref='nature_preferences')
  
-NatureName.language = relation(Language)
-
  NaturePokeathlonStat.pokeathlon_stat = relation(PokeathlonStat, backref='nature_effects')
  
  Pokedex.region = relation(Region, backref='pokedexes')
  NaturePokeathlonStat.pokeathlon_stat = relation(PokeathlonStat, backref='nature_effects')
  
  Pokedex.region = relation(Region, backref='pokedexes')
-Pokedex.version_groups = relation(VersionGroup, secondary=PokedexVersionGroup.__table__, backref='pokedexes')
-
-Pokemon.abilities = relation(Ability, secondary=PokemonAbility.__table__,
-                                      order_by=PokemonAbility.slot,
-                                      backref='pokemon')
-Pokemon.formes = relation(Pokemon, primaryjoin=Pokemon.id==Pokemon.forme_base_pokemon_id,
-                                               backref=backref('forme_base_pokemon',
-                                                               remote_side=[Pokemon.id]))
+Pokedex.version_groups = relation(VersionGroup, order_by=VersionGroup.id, back_populates='pokedex')
+
+Pokemon.all_abilities = relation(Ability,
+    secondary=PokemonAbility.__table__,
+    order_by=PokemonAbility.slot,
+)
+Pokemon.abilities = relation(Ability,
+    secondary=PokemonAbility.__table__,
+    primaryjoin=and_(
+        Pokemon.id == PokemonAbility.pokemon_id,
+        PokemonAbility.is_dream == False,
+    ),
+    order_by=PokemonAbility.slot,
+)
+Pokemon.dream_ability = relation(Ability,
+    secondary=PokemonAbility.__table__,
+    primaryjoin=and_(
+        Pokemon.id == PokemonAbility.pokemon_id,
+        PokemonAbility.is_dream == True,
+    ),
+    uselist=False,
+)
  Pokemon.pokemon_color = relation(PokemonColor, backref='pokemon')
  Pokemon.color = association_proxy('pokemon_color', 'name')
  Pokemon.dex_numbers = relation(PokemonDexNumber, order_by=PokemonDexNumber.pokedex_id.asc(), backref='pokemon')
  Pokemon.pokemon_color = relation(PokemonColor, backref='pokemon')
  Pokemon.color = association_proxy('pokemon_color', 'name')
  Pokemon.dex_numbers = relation(PokemonDexNumber, order_by=PokemonDexNumber.pokedex_id.asc(), backref='pokemon')
-Pokemon.default_form_sprite = relation(PokemonFormSprite,
-                                       primaryjoin=and_(
-                                            Pokemon.id==PokemonFormSprite.pokemon_id,
-                                            PokemonFormSprite.is_default==True,
-                                       ),
-                                       uselist=False)
  Pokemon.egg_groups = relation(EggGroup, secondary=PokemonEggGroup.__table__,
                                          order_by=PokemonEggGroup.egg_group_id,
  Pokemon.egg_groups = relation(EggGroup, secondary=PokemonEggGroup.__table__,
                                          order_by=PokemonEggGroup.egg_group_id,
-                                        backref='pokemon')
-Pokemon.evolution_chain = relation(EvolutionChain, backref='pokemon')
+                                        backref=backref('pokemon', order_by=Pokemon.order))
+Pokemon.evolution_chain = relation(EvolutionChain, back_populates='pokemon')
  Pokemon.child_pokemon = relation(Pokemon,
      primaryjoin=Pokemon.id==PokemonEvolution.from_pokemon_id,
      secondary=PokemonEvolution.__table__,
  Pokemon.child_pokemon = relation(Pokemon,
      primaryjoin=Pokemon.id==PokemonEvolution.from_pokemon_id,
      secondary=PokemonEvolution.__table__,
@@ -1057,14 +1608,21 @@ Pokemon.child_pokemon = relation(Pokemon,
      backref=backref('parent_pokemon', uselist=False),
  )
  Pokemon.flavor_text = relation(PokemonFlavorText, order_by=PokemonFlavorText.version_id.asc(), backref='pokemon')
      backref=backref('parent_pokemon', uselist=False),
  )
  Pokemon.flavor_text = relation(PokemonFlavorText, order_by=PokemonFlavorText.version_id.asc(), backref='pokemon')
-Pokemon.foreign_names = relation(PokemonName, backref='pokemon')
+Pokemon.forms = relation(PokemonForm, primaryjoin=Pokemon.id==PokemonForm.form_base_pokemon_id,
+                         order_by=(PokemonForm.order.asc(), PokemonForm.identifier.asc()))
+Pokemon.default_form = relation(PokemonForm,
+    primaryjoin=and_(Pokemon.id==PokemonForm.form_base_pokemon_id, PokemonForm.is_default==True),
+    uselist=False,
+)
  Pokemon.pokemon_habitat = relation(PokemonHabitat, backref='pokemon')
  Pokemon.habitat = association_proxy('pokemon_habitat', 'name')
  Pokemon.items = relation(PokemonItem, backref='pokemon')
  Pokemon.generation = relation(Generation, backref='pokemon')
  Pokemon.shape = relation(PokemonShape, backref='pokemon')
  Pokemon.stats = relation(PokemonStat, backref='pokemon', order_by=PokemonStat.stat_id.asc())
  Pokemon.pokemon_habitat = relation(PokemonHabitat, backref='pokemon')
  Pokemon.habitat = association_proxy('pokemon_habitat', 'name')
  Pokemon.items = relation(PokemonItem, backref='pokemon')
  Pokemon.generation = relation(Generation, backref='pokemon')
  Pokemon.shape = relation(PokemonShape, backref='pokemon')
  Pokemon.stats = relation(PokemonStat, backref='pokemon', order_by=PokemonStat.stat_id.asc())
-Pokemon.types = relation(Type, secondary=PokemonType.__table__, order_by=PokemonType.slot.asc())
+Pokemon.types = relation(Type, secondary=PokemonType.__table__,
+                               order_by=PokemonType.slot.asc(),
+                               back_populates='pokemon')
  
  PokemonDexNumber.pokedex = relation(Pokedex)
  
  
  PokemonDexNumber.pokedex = relation(Pokedex)
  
@@ -1099,16 +1657,28 @@ PokemonEvolution.party_pokemon = relation(Pokemon,
      primaryjoin=PokemonEvolution.party_pokemon_id==Pokemon.id,
      backref='triggered_evolutions',
  )
      primaryjoin=PokemonEvolution.party_pokemon_id==Pokemon.id,
      backref='triggered_evolutions',
  )
+PokemonEvolution.trade_pokemon = relation(Pokemon,
+    primaryjoin=PokemonEvolution.trade_pokemon_id==Pokemon.id,
+)
  
  PokemonFlavorText.version = relation(Version)
  
  
  PokemonFlavorText.version = relation(Version)
  
-PokemonItem.item = relation(Item, backref='pokemon')
-PokemonItem.version = relation(Version)
+PokemonForm.form_base_pokemon = relation(Pokemon, primaryjoin=PokemonForm.form_base_pokemon_id==Pokemon.id)
+PokemonForm.unique_pokemon = relation(Pokemon, backref=backref('unique_form', uselist=False),
+                                      primaryjoin=PokemonForm.unique_pokemon_id==Pokemon.id)
+PokemonForm.version_group = relation(VersionGroup)
+PokemonForm.form_group = association_proxy('form_base_pokemon', 'form_group')
+PokemonForm.pokeathlon_stats = relation(PokemonFormPokeathlonStat,
+                                        order_by=PokemonFormPokeathlonStat.pokeathlon_stat_id,
+                                        backref='pokemon_form')
  
  PokemonFormGroup.pokemon = relation(Pokemon, backref=backref('form_group',
                                                               uselist=False))
  
  PokemonFormGroup.pokemon = relation(Pokemon, backref=backref('form_group',
                                                               uselist=False))
-PokemonFormSprite.pokemon = relation(Pokemon, backref='form_sprites')
-PokemonFormSprite.introduced_in = relation(VersionGroup)
+
+PokemonFormPokeathlonStat.pokeathlon_stat = relation(PokeathlonStat)
+
+PokemonItem.item = relation(Item, backref='pokemon')
+PokemonItem.version = relation(Version)
  
  PokemonMove.pokemon = relation(Pokemon, backref='pokemon_moves')
  PokemonMove.version_group = relation(VersionGroup)
  
  PokemonMove.pokemon = relation(Pokemon, backref='pokemon_moves')
  PokemonMove.version_group = relation(VersionGroup)
@@ -1120,8 +1690,6 @@ PokemonMove.machine = relation(Machine, backref='pokemon_moves',
  PokemonMove.move = relation(Move, backref='pokemon_moves')
  PokemonMove.method = relation(PokemonMoveMethod)
  
  PokemonMove.move = relation(Move, backref='pokemon_moves')
  PokemonMove.method = relation(PokemonMoveMethod)
  
-PokemonName.language = relation(Language)
-
  PokemonStat.stat = relation(Stat)
  
  # This is technically a has-many; Generation.main_region_id -> Region.id
  PokemonStat.stat = relation(Stat)
  
  # This is technically a has-many; Generation.main_region_id -> Region.id
@@ -1132,6 +1700,8 @@ Region.version_groups = association_proxy('version_group_regions', 'version_grou
  
  Stat.damage_class = relation(MoveDamageClass, backref='stats')
  
  
  Stat.damage_class = relation(MoveDamageClass, backref='stats')
  
+StatHint.stat = relation(Stat, backref='hints')
+
  SuperContestCombo.first = relation(Move, primaryjoin=SuperContestCombo.first_move_id==Move.id,
                                          backref='super_contest_combo_first')
  SuperContestCombo.second = relation(Move, primaryjoin=SuperContestCombo.second_move_id==Move.id,
  SuperContestCombo.first = relation(Move, primaryjoin=SuperContestCombo.first_move_id==Move.id,
                                          backref='super_contest_combo_first')
  SuperContestCombo.second = relation(Move, primaryjoin=SuperContestCombo.second_move_id==Move.id,
@@ -1148,13 +1718,134 @@ Type.target_efficacies = relation(TypeEfficacy,
  
  Type.generation = relation(Generation, backref='types')
  Type.damage_class = relation(MoveDamageClass, backref='types')
  
  Type.generation = relation(Generation, backref='types')
  Type.damage_class = relation(MoveDamageClass, backref='types')
-Type.foreign_names = relation(TypeName, backref='type')
-
-TypeName.language = relation(Language)
+Type.pokemon = relation(Pokemon, secondary=PokemonType.__table__,
+                                 order_by=Pokemon.order,
+                                 back_populates='types')
+Type.moves = relation(Move, back_populates='type', order_by=Move.id)
  
  
-Version.version_group = relation(VersionGroup, backref='versions')
+Version.version_group = relation(VersionGroup, back_populates='versions')
  Version.generation = association_proxy('version_group', 'generation')
  
  Version.generation = association_proxy('version_group', 'generation')
  
+VersionGroup.versions = relation(Version, order_by=Version.id, back_populates='version_group')
  VersionGroup.generation = relation(Generation, backref='version_groups')
  VersionGroup.version_group_regions = relation(VersionGroupRegion, backref='version_group')
  VersionGroup.regions = association_proxy('version_group_regions', 'region')
  VersionGroup.generation = relation(Generation, backref='version_groups')
  VersionGroup.version_group_regions = relation(VersionGroupRegion, backref='version_group')
  VersionGroup.regions = association_proxy('version_group_regions', 'region')
+VersionGroup.pokedex = relation(Pokedex, back_populates='version_groups')
+
+### Convenience function
+def all_tables():
+    u"""Yields all tables in the pokédex"""
+    for table in set(t for t in globals().values() if isclass(t)):
+        if issubclass(table, TableBase) and table is not TableBase:
+            yield table
+
+
+### Add name tables
+for table in all_tables():
+    if issubclass(table, OfficiallyNamed):
+        cls = TextColumn
+        info=dict(description="The name", format='plaintext', official=True)
+    elif issubclass(table, UnofficiallyNamed):
+        cls = ProseColumn
+        info=dict(description="The name", format='plaintext', official=False)
+    else:
+        continue
+    table.name = cls(Unicode(class_mapper(table).c.identifier.type.length),
+        plural='names', nullable=False, info=info)
+
+### Add text/prose tables
+
+def makeTextTable(object_table, name_plural, name_singular, columns, lazy):
+    # With "Language", we'd have two language_id. So, rename one to 'lang'
+    safe_name = object_table.__singlename__
+    if safe_name == 'language':
+        safe_name = 'lang'
+
+    fields = {
+            safe_name + '_id': Column(Integer,
+                    ForeignKey(object_table.id), primary_key=True, nullable=False,
+                    info=dict(description="ID of the object this table represents")
+                ),
+            '__tablename__': table.__singlename__ + '_' + name_plural,
+            '__singlename__': table.__singlename__ + '_' + name_singular,
+            'is_%s_table' % name_singular: True,
+        }
+
+    fields.update((name, col) for name, plural, col in columns)
+
+    name = table.__name__ + name_singular.capitalize()
+
+    # There are some dynamic things that can only be set at class
+    # creation time because of declarative metaclass magic.
+    # So create class dynamically.
+    Strings = type(name, (TableBase, LanguageSpecific), fields)
+
+    # Alias the described thing to 'object', to make meta stuff easier
+    Strings.object_id = getattr(Strings, safe_name + '_id')
+
+    # The relation to the object
+    setattr(table, name_plural, relation(
+            Strings,
+            primaryjoin=(table.id == Strings.object_id),
+            backref=safe_name,
+            collection_class=attribute_mapped_collection('language'),
+            lazy=lazy,
+        ))
+
+    Strings.object = getattr(Strings, safe_name)
+
+    Strings.object_table = table
+    setattr(table, name_singular + '_table', Strings)
+
+    Strings.language = relation(
+            Language,
+            primaryjoin=Strings.language_id == Language.id,
+        )
+
+    for colname, pluralname, column in columns:
+        # Provide a relation with all the names, and an English accessor
+        # for backwards compatibility
+        def scope(colname, pluralname, column):
+            def get_string(self):
+                return dict(
+                        (l, getattr(t, colname))
+                        for l, t in getattr(self, name_plural).items()
+                    )
+
+            def get_english_string(self):
+                try:
+                    return get_string(self)['en']
+                except KeyError:
+                    raise AttributeError(colname)
+
+            setattr(table, pluralname, property(get_string))
+            setattr(table, colname, property(get_english_string))
+        scope(colname, pluralname, column)
+
+        if colname == 'name':
+            table.name_table = Strings
+
+    return Strings
+
+for table in all_tables():
+    text_columns = []
+    prose_columns = []
+    for colname in dir(table):
+        column = getattr(table, colname)
+        if isinstance(column, TextColumn):
+            text_columns.append((colname, column.plural, column.makeSAColumn()))
+        elif isinstance(column, ProseColumn):
+            prose_columns.append((colname, column.plural, column.makeSAColumn()))
+    if text_columns:
+        string_table = makeTextTable(table, 'texts', 'text', text_columns, lazy=False)
+        globals()[string_table.__name__] = string_table
+    if prose_columns:
+        string_table = makeTextTable(table, 'prose', 'prose', prose_columns, lazy=True)
+        globals()[string_table.__name__] = string_table
+    if (text_columns or prose_columns) and issubclass(table, LanguageSpecific):
+        raise AssertionError("Language-specific table %s shouldn't have explicit language-specific columns" % table)
+
+### Add language relations
+for table in all_tables():
+    if issubclass(table, LanguageSpecific):
+        table.language = relation(Language, primaryjoin=table.language_id == Language.id)