| 1 |
from __future__ import annotations |
| 2 |
|
| 3 |
from dataclasses import ( |
| 4 |
fields, |
| 5 |
is_dataclass, |
| 6 |
replace, |
| 7 |
) |
| 8 |
from typing import ( |
| 9 |
Protocol, |
| 10 |
TYPE_CHECKING, |
| 11 |
) |
| 12 |
|
| 13 |
if TYPE_CHECKING: |
| 14 |
from _typeshed import DataclassInstance as _DataclassInstance |
| 15 |
|
| 16 |
class _HasName(Protocol, _DataclassInstance): |
| 17 |
name: str |
| 18 |
|
| 19 |
|
| 20 |
def default[T: _DataclassInstance]( |
| 21 |
cls: type[T], |
| 22 |
/, |
| 23 |
) -> T: |
| 24 |
f = {} |
| 25 |
|
| 26 |
for field in fields(cls): |
| 27 |
if 'default' in field.metadata: |
| 28 |
f[field.name] = field.metadata['default'] |
| 29 |
|
| 30 |
return cls(**f) |
| 31 |
|
| 32 |
|
| 33 |
def merge[T: _DataclassInstance]( |
| 34 |
self: T, |
| 35 |
other: T | None, /, |
| 36 |
) -> T: |
| 37 |
if other is None: |
| 38 |
return self |
| 39 |
|
| 40 |
f = {} |
| 41 |
|
| 42 |
for field in fields(self): |
| 43 |
if not field.init: |
| 44 |
continue |
| 45 |
|
| 46 |
field_default_type = object |
| 47 |
if isinstance(field.default_factory, type): |
| 48 |
field_default_type = field.default_factory |
| 49 |
|
| 50 |
self_field = getattr(self, field.name) |
| 51 |
other_field = getattr(other, field.name) |
| 52 |
|
| 53 |
if field.name == 'name': |
| 54 |
assert self_field == other_field |
| 55 |
elif field.type == 'bool': |
| 56 |
f[field.name] = other_field |
| 57 |
elif field.metadata.get('merge') == 'assoclist': |
| 58 |
f[field.name] = _merge_assoclist(self_field, other_field) |
| 59 |
elif is_dataclass(field_default_type): |
| 60 |
f[field.name] = merge(self_field, other_field) |
| 61 |
elif issubclass(field_default_type, list): |
| 62 |
f[field.name] = self_field + other_field |
| 63 |
elif issubclass(field_default_type, dict): |
| 64 |
f[field.name] = self_field | other_field |
| 65 |
elif field.default is None: |
| 66 |
if other_field is not None: |
| 67 |
f[field.name] = other_field |
| 68 |
else: |
| 69 |
raise RuntimeError(f'Unable to merge for type {field.type}') |
| 70 |
|
| 71 |
return replace(self, **f) |
| 72 |
|
| 73 |
|
| 74 |
def merge_default[T: _DataclassInstance]( |
| 75 |
cls: type[T], |
| 76 |
/, |
| 77 |
*others: T, |
| 78 |
) -> T: |
| 79 |
ret: T = default(cls) |
| 80 |
for o in others: |
| 81 |
ret = merge(ret, o) |
| 82 |
return ret |
| 83 |
|
| 84 |
|
| 85 |
def _merge_assoclist[T: _HasName]( |
| 86 |
self_list: list[T], |
| 87 |
other_list: list[T], |
| 88 |
/, |
| 89 |
) -> list[T]: |
| 90 |
''' |
| 91 |
Merge lists where each item got a "name" attribute |
| 92 |
''' |
| 93 |
if not self_list: |
| 94 |
return other_list |
| 95 |
if not other_list: |
| 96 |
return self_list |
| 97 |
|
| 98 |
ret: list[T] = [] |
| 99 |
other_dict = { |
| 100 |
i.name: i |
| 101 |
for i in other_list |
| 102 |
} |
| 103 |
for i in self_list: |
| 104 |
if i.name in other_dict: |
| 105 |
ret.append(merge(i, other_dict.pop(i.name))) |
| 106 |
else: |
| 107 |
ret.append(i) |
| 108 |
ret.extend(other_dict.values()) |
| 109 |
return ret |