SQLAlchemy 从非 orm 继承 class

Question

我正在尝试开发我的非 ORM class 的 ORM 版本，以便能够将对象存储在数据库中（并在可能的情况下将其检索回来）。

from ruamel.yaml import YAMLObject

class User(YAMLObject):
    yaml_tag = u'user'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    # Other useful methods

我现在想要实现的是一个类似的对象，它在 Python 世界中的行为类似于 User，但它也可以用作 ORM 对象，因此能够存储它在数据库中。我巧妙地尝试的是：

Base = declarative_base()

class SQLUser(Base, User):

    id = Column(Integer, primary_key=True)
    name = Column(String)
    age = Column(Integer)

    def __init__(self, name, age):
        self.name = name
        self.age = age

运行使用此 class 层次结构的示例会在 Python 2 上产生以下错误：

TypeError: Error when calling the metaclass bases metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases

我相信这与 YAMLObject metaclass... 有关，但我需要它，因为我还希望能够将这些对象保存为 YAML。对于我读到的关于这个错误的内容，我也许应该使用第三个 metaclass，它继承了 YAMLObject metaclass 和 Base，然后用它来创建 class我要...

class MetaMixinUser(type(User), type(Base)):
    pass

class SQLUser(six.with_metaclass(MetaMixinUser)):
    #[...]

不幸的是，这会产生另一个错误：

AttributeError: type object 'SQLUser' has no attribute '_decl_class_registry'

你能指出我的推理哪里有缺陷吗？

Answer 1

如果您赶时间：从 ruamel.yaml 0.15.19 开始，您可以 register classes 使用一条语句，而无需 YAMLObject 的子class:

yaml = ruamel.yaml.YAML()
yaml.register_class(User)

YAMLObject 是为了向后兼容 PyYAML，虽然它可能很方便，但我不能真正推荐使用它，原因有以下三个：

它使您的 class 层次结构依赖于 YAMLObject，正如您所注意到的，这可能会干扰其他依赖性
默认使用不安全Loader
基于 Python 装饰器的解决方案将同样方便且侵入性小得多。

subclassing YAMLObject 做的唯一真实的事情是为那个 yaml_tag 注册一个 constructor 和为 sub[=84 注册一个 representer =].

如果您运行 Python 2.

，则所有示例均假定 from __future__ import print_function

如果你有以下情况，基于 subclassing YAMLObject:

import sys
import ruamel.yaml
from ruamel.std.pathlib import Path

yaml = ruamel.yaml.YAML(typ='unsafe')

class User(ruamel.yaml.YAMLObject):
    yaml_tag = u'user'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def to_yaml(cls, representer, node):
        return representer.represent_scalar(cls.yaml_tag, 
                                            u'{.name}-{.age}'.format(node, node))

    @classmethod
    def from_yaml(cls, constructor, node):
        # type: (Any, Any) -> Any
        return User(*node.value.split('-'))


data = {'users': [User('Anthon', 18)]}
yaml.dump(data, sys.stdout)
print()
tmp_file = Path('tmp.yaml')
yaml.dump(data, tmp_file)
rd = yaml.load(tmp_file)
print(rd['users'][0].name, rd['users'][0].age)

那会让你：

users: [!<user> Anthon-18]

Anthon 18

你可以在没有子classing的情况下得到完全相同的结果，方法是：

import sys
import ruamel.yaml
from ruamel.std.pathlib import Path

yaml = ruamel.yaml.YAML(typ='safe')

class User(object):
    yaml_tag = u'user'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def to_yaml(cls, representer, node):
        return representer.represent_scalar(cls.yaml_tag, 
                                            u'{.name}-{.age}'.format(node, node))

    @classmethod
    def from_yaml(cls, constructor, node):
        # type: (Any, Any) -> Any
        return User(*node.value.split('-'))


yaml.representer.add_representer(User, User.to_yaml)
yaml.constructor.add_constructor(User.yaml_tag, User.from_yaml)

data = {'users': [User('Anthon', 18)]}

yaml.dump(data, sys.stdout)
print()
tmp_file = Path('tmp.yaml')
yaml.dump(data, tmp_file)
rd = yaml.load(tmp_file)
print(rd['users'][0].name, rd['users'][0].age)

上面使用了SafeLoader（和SafeDumper），这是朝着正确方向迈出的一步。但是，如果您有很多 class，那么在上面添加 XXXX.add_YYY 行会很麻烦，因为这些条目几乎相同，但不完全相同。而且它不处理 classes 缺少一个或两个 to_yaml 和 from_yaml.

为了解决上面的问题，我建议你在文件 myyaml.py:

中创建一个装饰器 yaml_object 和一个助手 class

import ruamel.yaml

yaml = ruamel.yaml.YAML(typ='safe')

class SafeYAMLObject(object):
    def __init__(self, cls):
        self._cls = cls

    def to_yaml(self, representer, data):
        return representer.represent_yaml_object(
            self._cls.yaml_tag, data, self._cls,
            flow_style=representer.default_flow_style)

    def from_yaml(self, constructor, node):
        return constructor.construct_yaml_object(node, self._cls)

def yaml_object(cls):
    yaml.representer.add_representer(
        cls, getattr(cls, 'to_yaml', SafeYAMLObject(cls).to_yaml))
    yaml.constructor.add_constructor(
        cls.yaml_tag, getattr(cls, 'from_yaml', SafeYAMLObject(cls).from_yaml))
    return cls

有了它你可以做：

import sys
from ruamel.std.pathlib import Path
from myyaml import yaml, yaml_object

@yaml_object
class User(object):
    yaml_tag = u'user'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def to_yaml(cls, representer, node):
        return representer.represent_scalar(cls.yaml_tag, 
                                            u'{.name}-{.age}'.format(node, node))

    @classmethod
    def from_yaml(cls, constructor, node):
        # type: (Any, Any) -> Any
        return User(*node.value.split('-'))


data = {'users': [User('Anthon', 18)]}

yaml.dump(data, sys.stdout)
print()
tmp_file = Path('tmp.yaml')
yaml.dump(data, tmp_file)
rd = yaml.load(tmp_file)
print(rd['users'][0].name, rd['users'][0].age)

同样的结果。如果删除 to_yaml 和 from_yaml 方法，您将获得相同的最终值，但 YAML 略有不同：

users:
- !<user> {age: 18, name: Anthon}

Anthon 18

我无法测试这个，但是使用这个装饰器而不是 subclassing YAMLObject 应该在做时摆脱 TypeError:

class SQLUser(Base, User):

¹ _{免责声明：我是此答案中使用的 ruamel.yaml 包的作者。

免责声明 2：我不是真的 18 岁，但我确实遵循 Brian Adams 在 this 专辑}

的主打歌中表达的副词

SQLAlchemy 从非 orm 继承 class

SQLAlchemy inheritance from non-orm class

python

inheritance

orm

sqlalchemy

ruamel.yaml