Python 如何制作；“仅关键字”；有数据类的字段？

支持仅生成参数关键字：

class S3Obj:
    def __init__(self, bucket, key, *, storage_class='Standard'):
        self.bucket = bucket
        self.key = key
        self.storage_class = storage_class

如何使用计算机获取这种签名？类似于此，但最好不使用

SyntaxError

：

@dataclass
class S3Obj:
    bucket: str
    key: str
    *
    storage_class: str = 'Standard'

理想情况下是声明式的，但是使用

\uuuu post\u init\uuuu

钩子和/或替换类装饰器也可以，只要代码是可重用的

编辑：可能类似于这种语法，使用省略号文字

@mydataclass
class S3Obj:
    bucket: str
    key: str
    ...
    storage_class: str = 'Standard'

---

这样做时，您不会从

dataclasses

获得太多帮助。没有办法说字段应该只由关键字参数初始化，

\uuuu post\u init\uuu

钩子不知道原始构造函数参数是否由关键字传递。此外，没有好的方法来内省

InitVar

s，更不用说将

InitVar

s标记为关键字了

至少，您必须替换生成的

\uuuu init\uuuu

。可能最简单的方法就是手工定义

\uuuuu init\uuuu

。如果您不想这样做，最可靠的方法可能是创建字段对象并在

元数据中标记它们，然后在您自己的decorator中检查元数据。这比听起来还要复杂：

import dataclasses
import functools
import inspect

# Helper to make calling field() less verbose
def kwonly(default=dataclasses.MISSING, **kwargs):
    kwargs.setdefault('metadata', {})
    kwargs['metadata']['kwonly'] = True
    return dataclasses.field(default=default, **kwargs)

def mydataclass(_cls, *, init=True, **kwargs):
    if _cls is None:
        return functools.partial(mydataclass, **kwargs)

    no_generated_init = (not init or '__init__' in _cls.__dict__)
    _cls = dataclasses.dataclass(_cls, **kwargs)
    if no_generated_init:
        # No generated __init__. The user will have to provide __init__,
        # and they probably already have. We assume their __init__ does
        # what they want.
        return _cls

    fields = dataclasses.fields(_cls)
    if any(field.metadata.get('kwonly') and not field.init for field in fields):
        raise TypeError('Non-init field marked kwonly')

    # From this point on, ignore non-init fields - but we don't know
    # about InitVars yet.
    init_fields = [field for field in fields if field.init]
    for i, field in enumerate(init_fields):
        if field.metadata.get('kwonly'):
            first_kwonly = field.name
            num_kwonly = len(init_fields) - i
            break
    else:
        # No kwonly fields. Why were we called? Assume there was a reason.
        return _cls

    if not all(field.metadata.get('kwonly') for field in init_fields[-num_kwonly:]):
        raise TypeError('non-kwonly init fields following kwonly fields')

    required_kwonly = [field.name for field in init_fields[-num_kwonly:]
                       if field.default is field.default_factory is dataclasses.MISSING]

    original_init = _cls.__init__

    # Time to handle InitVars. This is going to get ugly.
    # InitVars don't show up in fields(). They show up in __annotations__,
    # but the current dataclasses implementation doesn't understand string
    # annotations, and we want an implementation that's robust against
    # changes in string annotation handling.
    # We could inspect __post_init__, except there doesn't have to be a
    # __post_init__. (It'd be weird to use InitVars with no __post_init__,
    # but it's allowed.)
    # As far as I can tell, that leaves inspecting __init__ parameters as
    # the only option.

    init_params = tuple(inspect.signature(original_init).parameters)
    if init_params[-num_kwonly] != first_kwonly:
        # InitVars following kwonly fields. We could adopt a convention like
        # "InitVars after kwonly are kwonly" - in fact, we could have adopted
        # "all fields after kwonly are kwonly" too - but it seems too likely
        # to cause confusion with inheritance.
        raise TypeError('InitVars after kwonly fields.')
    # -1 to exclude self from this count.
    max_positional = len(init_params) - num_kwonly - 1

    @functools.wraps(original_init)
    def __init__(self, *args, **kwargs):
        if len(args) > max_positional:
            raise TypeError('Too many positional arguments')
        check_required_kwargs(kwargs, required_kwonly)
        return original_init(self, *args, **kwargs)
    _cls.__init__ = __init__

    return _cls

def check_required_kwargs(kwargs, required):
    # Not strictly necessary, but if we don't do this, error messages for
    # required kwonly args will list them as positional instead of
    # keyword-only.
    missing = [name for name in required if name not in kwargs]
    if not missing:
        return
    # We don't bother to exactly match the built-in logic's exception
    raise TypeError(f"__init__ missing required keyword-only argument(s): {missing}")

用法示例：

@mydataclass
class S3Obj:
    bucket: str
    key: str
    storage_class: str = kwonly('Standard')

这是经过一些测试的，但不像我希望的那样彻底


您无法使用
..
获得您建议的语法，因为
..
不会做元类或装饰程序可以看到的任何事情。您可以获得一些非常接近于实际触发名称查找或赋值的东西，比如
kwonly\u start=True
，这样元类就可以看到它的发生。然而，这方面的健壮实现编写起来很复杂，因为有很多事情需要专门处理。继承、
typing.ClassVar
、
dataclasses.InitVar
、注释中的转发引用等，如果不小心处理，都会导致问题。继承可能会导致最多的问题

无法处理所有精细位的概念验证可能如下所示：

# Does not handle inheritance, InitVar, ClassVar, or anything else
# I'm forgetting.

class POCMetaDict(dict):
    def __setitem__(self, key, item):
        # __setitem__ instead of __getitem__ because __getitem__ is
        # easier to trigger by accident.
        if key == 'kwonly_start':
            self['__non_kwonly'] = len(self['__annotations__'])
        super().__setitem__(key, item)

class POCMeta(type):
    @classmethod
    def __prepare__(cls, name, bases, **kwargs):
        return POCMetaDict()
    def __new__(cls, name, bases, classdict, **kwargs):
        classdict.pop('kwonly_start')
        non_kwonly = classdict.pop('__non_kwonly')

        newcls = super().__new__(cls, name, bases, classdict, **kwargs)
        newcls = dataclass(newcls)

        if non_kwonly is None:
            return newcls

        original_init = newcls.__init__

        @functools.wraps(original_init)
        def __init__(self, *args, **kwargs):
            if len(args) > non_kwonly:
                raise TypeError('Too many positional arguments')
            return original_init(self, *args, **kwargs)

        newcls.__init__ = __init__
        return newcls

你会像这样使用它

class S3Obj(metaclass=POCMeta):
    bucket: str
    key: str

    kwonly_start = True

    storage_class: str = 'Standard'

这是未经测试的。
我想知道为什么这不是dataclass API的一部分，这对我来说很重要

如果所有的参数都是关键字参数，可能会简单一点，下面的内容就足够了

从数据类导入数据类
从functools导入包装
仅限def kwargs_（cls）：
@包装（cls）
def呼叫（**kwargs）：
返回cls（**kwargs）
回电
@仅kwargs_
@数据类
类坐标：
纬度：浮点=0
经度：float=0

这并不完美，因为使用位置参数时出现的错误引用了
call
：

--------------------------------------------------------
TypeError回溯（最近一次调用上次）
在里面
---->1c=坐标（1，经度=2）
2帮助（c）
TypeError:call（）接受0个位置参数，但给出了1个

类似地，dataclass的构造函数文档已经过时，并且没有反映新的约束

如果只有一些关键字字段，可能是这个

def kwargs（*关键字）：
def装饰器（cls）：
@包装（cls）
def调用（*args，**kwargs）：
如果有（千瓦不以千瓦为单位，而千瓦以关键字为单位）：
raise TypeError（f“{cls.\uuuuuu name\uuuuuu}.\uuuuu init\uuuuuuuu（）需要{keywords}作为关键字参数”）
返回cls（*args，**kwargs）
回电
返回装饰器
@kwargs（“经度”）
@数据类（冻结=真）
类坐标：
纬度：浮动
经度：float=0
..
不会执行任何其他代码可以看到的操作。