Python实现支持持久化的单例装饰器

import os
import types
from functools import wraps
from typing import TypeVar
import jsonpickle
from pydantic import BaseModel


T = TypeVar('T')

def single(cls_or_filename: T|str = None, *,filename:str=None) -> T:
    """单例装饰器：
        - @single / @single() ：仅单例，实例获得 save(filename) 方法
        - @single('path/file.json') / @single(filename='path/file.json') ：
        指定持久化文件，首次创建时若文件存在则从中恢复；实例获得 save() 方法
        """
    if isinstance(cls_or_filename, type):
        # @single 直接装饰类
        fname = cls_or_filename.__qualname__ + '.json'  # 默认文件名是类名 + .json
        return _decorate(cls_or_filename, fname)  # type: ignore[return-value]
    else:
        fname = cls_or_filename if cls_or_filename is not None else filename
        # 注意：不能直接'return _decorate(cls, fname)'，因为此时还没有传入cls
        def decorator(cls: T):
            return _decorate(cls, fname)
        return decorator

def _decorate(cls: T, fname: str) -> T:
    _instance: T = None  # 单例实例
    # 用于 jsonpickle 解码时的类映射，避免递归调用 wrapper
    class_fullname = cls.__module__ + '.' + cls.__qualname__
    class_mapping = {class_fullname: cls}
    @wraps(cls)
    def wrapper(*args, **kwargs) -> T:
        nonlocal _instance
        if _instance is None:
            if fname is not None and os.path.exists(fname):
                with open(fname, 'r', encoding='utf-8') as f:
                    _instance = jsonpickle.decode(f.read(), classes=class_mapping)
            else:
                _instance = cls(*args, **kwargs)
            # 动态添加 save 方法
            if not hasattr(_instance, 'save'):
                def save(self, filename: str = None):
                    save_path = filename or fname
                    if save_path is None:
                        raise ValueError(
                            "No filename specified. Either provide a filename to save() "
                            "or use the decorator with a filename."
                        )
                    with open(save_path, 'w', encoding='utf-8') as f:
                        f.write(jsonpickle.encode(self))
                # 为了防止pydantic禁止动态添加字段，这里使用object.__setattr__强制添加
                object.__setattr__(_instance, 'save', types.MethodType(save, _instance))
        return _instance  # type: ignore[return-value]
    return wrapper

@single                    # 无参数，默认文件名是 类名.json
@single()                 # 同上
@single('b.json')         # 指定文件名
@single(filename='b.json') # 关键字参数指定文件名

if isinstance(cls_or_filename, type):
    # @single 直接装饰类，此时第一个参数就是类本身
    return _decorate(cls_or_filename, fname)
else:
    # @single('file.json') 两段式调用，先返回一个 decorator，再注入 cls
    def decorator(cls: T):
        return _decorate(cls, fname)
    return decorator

class_fullname = cls.__module__ + '.' + cls.__qualname__
class_mapping = {class_fullname: cls}
_instance = jsonpickle.decode(f.read(), classes=class_mapping)

object.__setattr__(_instance, 'save', types.MethodType(save, _instance))

@single
class A:
    def __init__(self, x: int = 0):
        self.x = x

a = A(5)
print(type(a))    # <class '__main__.A'>，类型依然是 A
print(a.x)        # 5
a.save()          # 保存到 A.json

@single('b.json')
class B:
    def __init__(self, y: str = ''):
        self.y = y

b = B('hello')
b.save()  # 保存到 b.json

@single
class Task(BaseModel):
    id: str = 'id'
    label: str = 'label'
    children: list['Task'] = []

t = Task()
print(t.id)     # id
print(t.label)  # label
t.save()        # 正常保存，不会被 Pydantic 拦截