Обновление: в Python 3.10 появился новый dataclasses.KW_ONLY
дозорный это работает так:
@dataclasses.dataclass
class Example:
a: int
b: int
_: dataclasses.KW_ONLY
c: int
d: int
Любые поля после псевдополя KW_ONLY
содержат только ключевые слова.
В декораторе dataclasses.dataclass
также есть параметр kw_only
, который делает все поля только ключевыми словами:
@dataclasses.dataclass(kw_only=True)
class Example:
a: int
b: int
Также можно передать kw_only=True
в dataclasses.field
, чтобы пометить отдельные поля как содержащие только ключевые слова.
Если поля, содержащие только ключевые слова, идут после полей, содержащих не только ключевые слова (возможно с наследованием или путем индивидуальной маркировки полей, содержащих только ключевые слова), поля, содержащие только ключевые слова, будут переупорядочен после других полей, специально для целей __init__
. Другие функции класса данных сохранят заявленный порядок. Такое переупорядочение сбивает с толку, и его, вероятно, следует избегать.
Pre-Python 3.10 ответ:
Вы не получите большой помощи от dataclasses
, делая это. Невозможно сказать, что поле должно быть инициализировано аргументом, состоящим только из ключевого слова, и хук __post_init__
не знает, были ли исходные аргументы конструктора переданы по ключевому слову. Кроме того, нет хорошего способа проанализировать InitVar
s, не говоря уже о том, чтобы пометить InitVar
s только как ключевые слова.
Как минимум, вам придется заменить сгенерированный файл __init__
. Вероятно, самый простой способ — просто определить __init__
вручную. Если вы не хотите этого делать, вероятно, самый надежный способ — создать объекты поля и пометить их kwonly в metadata
, а затем проверить метаданные в вашем собственном декораторе. Это даже сложнее, чем кажется:
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_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'
Это не проверено.
person
user2357112 supports Monica
schedule
19.04.2018
...
не сделает ничего, что мог бы увидеть любой другой код. - person user2357112 supports Monica   schedule 19.04.2018