X-Git-Url: http://git.veekun.com/zzz-pokedex.git/blobdiff_plain/3a8097b37302ff0c1fa922407cf7bcfd853a1989..ac248d586cbc7b919835cb7f39dd741d79283229:/pokedex/db/tables.py diff --git a/pokedex/db/tables.py b/pokedex/db/tables.py index 6e23ebf..828b902 100644 --- a/pokedex/db/tables.py +++ b/pokedex/db/tables.py @@ -34,7 +34,7 @@ from sqlalchemy.ext.declarative import ( ) from sqlalchemy.ext.associationproxy import association_proxy from sqlalchemy.orm import ( - backref, eagerload_all, relation, class_mapper, synonym, mapper, + backref, compile_mappers, eagerload_all, relation, class_mapper, synonym, mapper, ) from sqlalchemy.orm.session import Session, object_session from sqlalchemy.orm.collections import attribute_mapped_collection @@ -56,25 +56,34 @@ class TableMetaclass(DeclarativeMeta): if hasattr(cls, '__tablename__'): table_classes.append(cls) -metadata = MetaData() -TableBase = declarative_base(metadata=metadata, metaclass=TableMetaclass) - -### Helper classes -# XXX this stuff isn't covered anywhere; maybe put it in TableBase?? -class Named(object): - """Mixin for objects that have names""" +class TableSuperclass(object): + """Superclass for declarative tables, to give them some generic niceties + like stringification. + """ def __unicode__(self): + """Be as useful as possible. Show the primary key, and an identifier + if we've got one. + """ + typename = u'.'.join((__name__, type(self).__name__)) + + pk_constraint = self.__table__.primary_key + if not pk_constraint: + return u"<%s object at %x>" % (typename, id(self)) + + pk = u', '.join(unicode(getattr(self, column.name)) + for column in pk_constraint.columns) try: - return '<%s: %s>' % (type(self).__name__, self.identifier) + return u"<%s object (%s): %s>" % (typename, pk, self.identifier) except AttributeError: - return '<%s>' % type(self).__name__ + return u"<%s object (%s)>" % (typename, pk) def __str__(self): - return unicode(self).encode('utf-8') + return unicode(self).encode('utf8') - def __repr__(self): - return str(self) +metadata = MetaData() +TableBase = declarative_base(metadata=metadata, cls=TableSuperclass, metaclass=TableMetaclass) +### Helper classes class LanguageSpecific(object): """Mixin for prose and text tables""" @declared_attr @@ -1853,46 +1862,44 @@ VersionGroup.pokedex = relation(Pokedex, back_populates='version_groups') default_lang = u'en' -def makeTextTable(object_table, name_plural, name_singular, columns, lazy): +def makeTextTable(foreign_table_class, table_suffix_plural, table_suffix_singular, columns, lazy, Language=Language): # 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' + foreign_key_name = foreign_table_class.__singlename__ + if foreign_key_name == 'language': + foreign_key_name = 'lang' - tablename = object_table.__singlename__ + '_' + name_plural - singlename = object_table.__singlename__ + '_' + name_singular + table_name = foreign_table_class.__singlename__ + '_' + table_suffix_plural - class Strings(object): - __tablename__ = tablename - __singlename__ = singlename - _attrname = name_plural + class TranslatedStringsTable(object): + __tablename__ = table_name + _attrname = table_suffix_plural _language_identifier = association_proxy('language', 'identifier') - for name, plural, column in columns: - column.name = name + for column_name, column_name_plural, column in columns: + column.name = column_name if not column.nullable: # A Python side default value, so that the strings can be set # one by one without the DB complaining about missing values column.default = ColumnDefault(u'') - table = Table(tablename, metadata, - Column(safe_name + '_id', Integer, ForeignKey(object_table.id), + table = Table(table_name, foreign_table_class.__table__.metadata, + Column(foreign_key_name + '_id', Integer, ForeignKey(foreign_table_class.id), primary_key=True, nullable=False), Column('language_id', Integer, ForeignKey(Language.id), primary_key=True, index=True, nullable=False), *(column for name, plural, column in columns) ) - mapper(Strings, table, + mapper(TranslatedStringsTable, table, properties={ - "object_id": synonym(safe_name + '_id'), + "object_id": synonym(foreign_key_name + '_id'), "language": relation(Language, primaryjoin=table.c.language_id == Language.id, ), - safe_name: relation(object_table, - primaryjoin=(object_table.id == table.c[safe_name + "_id"]), - backref=backref(name_plural, - collection_class=attribute_mapped_collection('language'), + foreign_key_name: relation(foreign_table_class, + primaryjoin=(foreign_table_class.id == table.c[foreign_key_name + "_id"]), + backref=backref(table_suffix_plural, + collection_class=attribute_mapped_collection('_language_identifier'), lazy=lazy, ), ), @@ -1900,110 +1907,41 @@ def makeTextTable(object_table, name_plural, name_singular, columns, lazy): ) # The relation to the object - Strings.object = getattr(Strings, safe_name) + TranslatedStringsTable.object = getattr(TranslatedStringsTable, foreign_key_name) # Link the tables themselves, so we can get them if needed - Strings.object_table = object_table - setattr(object_table, name_singular + '_table', Strings) + TranslatedStringsTable.foreign_table_class = foreign_table_class + setattr(foreign_table_class, table_suffix_singular + '_table', TranslatedStringsTable) - for colname, pluralname, column in columns: + for column_name, column_name_plural, column in columns: # Provide a property with all the names, and an English accessor # for backwards compatibility - setattr(object_table, pluralname, StringProperty( - object_table, Strings, colname, - )) - setattr(object_table, colname, DefaultLangProperty(pluralname)) - - if colname == 'name': - object_table.name_table = Strings + def text_string_creator(language_code, string): + row = TranslatedStringsTable() + row._language_identifier = language_code + setattr(row, column_name, string) + return row - return Strings + setattr(foreign_table_class, column_name_plural, + association_proxy(table_suffix_plural, column_name, creator=text_string_creator)) + setattr(foreign_table_class, column_name, DefaultLangProperty(column_name_plural)) -class StringProperty(object): - def __init__(self, cls, stringclass, colname): - self.cls = cls - self.colname = colname - self.stringclass = stringclass - - def __get__(self, instance, cls): - if instance: - return StringMapping(instance, self) - else: - return self - - def __getitem__(self, lang): - return StringExpression(self, lang) - - def __str__(self): - return '' % (self.cls, self.colname) - -class StringMapping(collections.MutableMapping): - def __init__(self, instance, prop): - self.stringclass = prop.stringclass - self.instance = instance - self.strings = getattr(instance, prop.stringclass._attrname) - self.colname = prop.colname - - def __len__(self): - return len(self.strings) - - def __iter__(self): - return iter(self.strings) - - def __contains__(self, lang): - return lang in self.strings - - def __getitem__(self, lang): - return getattr(self.strings[lang], self.colname) - - def __setitem__(self, lang, value): - try: - # Modifying an existing row - row = self.strings[lang] - except KeyError: - # We need do add a whole row for the language - row = self.stringclass() - row.object_id = self.instance.id - session = object_session(self.instance) - if isinstance(lang, basestring): - lang = session.query(Language).filter_by( - identifier=lang).one() - row.language = lang - self.strings[lang] = row - session.add(row) - return setattr(row, self.colname, value) - - def __delitem__(self, lang): - raise NotImplementedError('Cannot delete a single string. ' - 'Perhaps you wan to delete all of %s.%s?' % - (self.instance, self.stringclass._attrname) - ) - -class StringExpression(ColumnOperators): - def __init__(self, prop, lang): - self.prop = prop - self.column = getattr(prop.stringclass, prop.colname) - self.lang_column = prop.stringclass._language_identifier - if isinstance(lang, basestring): - self.lang = lang - else: - self.lang = lang.identifier + if column_name == 'name': + foreign_table_class.name_table = TranslatedStringsTable - def operate(self, op, *values, **kwargs): - return getattr(self.prop.cls, self.prop.stringclass._attrname).any(and_( - self.lang_column == self.lang, - op(self.column, *values, **kwargs), - )) + compile_mappers() + return TranslatedStringsTable class DefaultLangProperty(object): - def __init__(self, colname): - self.colname = colname + def __init__(self, column_name): + self.column_name = column_name def __get__(self, instance, cls): if instance: - return getattr(instance, self.colname)[default_lang] + return getattr(instance, self.column_name)[default_lang] else: - return getattr(cls, self.colname)[default_lang] + # TODO I think this is kind of broken + return getattr(cls, self.column_name)[default_lang] def __set__(self, instance, value): getattr(instance, self.colname)[default_lang] = value @@ -2038,7 +1976,7 @@ for table in list(table_classes): if text_columns: string_table = makeTextTable(table, 'texts', 'text', text_columns, lazy=False) if prose_columns: - string_table = makeTextTable(table, 'prose', 'prose', prose_columns, lazy=True) + string_table = makeTextTable(table, 'prose', 'prose', prose_columns, lazy='select') ### Add language relations for table in list(table_classes):