python - SQLAlchemy 从非 orm 类继承

Question

我正在尝试开发非 ORM 类的 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

在 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 元类有关...但我需要它，因为我还希望能够将这些对象保存为 YAML。对于我读到的有关此错误的信息，我也许应该使用第三个元类，该元类继承自 YAMLObject 元类和 Base，然后使用它来创建我想要的类。 .

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 子类化:

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

<小时/>

YAMLObject 是为了与 PyYAML 向后兼容，虽然它可能很方便，但我真的不建议使用它，原因有三个:

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

子类化 YAMLObject 所做的唯一真正的事情是为该 yaml_tag 注册一个 constructor 并为该 yaml_tag 注册一个 representer子类。

如果您运行 Python 2，所有示例均假设 from __future__ import print_function。

如果您有以下内容，基于子类化 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

您无需子类化即可获得完全相同的结果，方法是:

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)，这是朝着正确方向迈出的一步。但是，如果您有很多类，则添加上面的 XXXX.add_YYY 行会很麻烦，因为这些条目几乎相同，但不完全相同。而且它不处理缺少 to_yaml 和 from_yaml 之一或两者的类。

为了解决上述问题，我建议您在文件 myyaml.py 中创建一个装饰器 yaml_object 和一个辅助类:

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

我无法对此进行测试，但使用此装饰器而不是子类化 YAMLObject 应该在执行以下操作时摆脱 TypeError:

class SQLUser(Base, User):

<小时/>

1 <子>免责声明:我是本答案中使用的 ruamel.yaml 包的作者。
免责声明2:我并不是真正的18岁，但我确实遵循Brian Adams在this的主打歌中表达的陈述句。专辑