def test_subtracting_with_set_and_dict():
curr_dict = {
"translation": {
"filters": {
"values": Ellipsis,
"reports": {
"report": {
"charts": {
"chart": Ellipsis
}
}
},
},
"translations": {
"language": Ellipsis
},
"filtervalues": {
"filter": {
"reports": {
"report": {
"charts": {
"chart": Ellipsis
}
}
}
}
},
},
"chart": {
"reports": {
"report": {
"filters": {
"filter": {
"translation": {
"translations": {
"language": Ellipsis
},
"filtervalues": Ellipsis,
},
"values": {
"translation": {
"translations": {
"language": Ellipsis
}
}
},
}
}
}
}
},
}
dict_to_update = {
"chart": Ellipsis,
"translation": {"filters", "filtervalues", "chartcolumns"},
}
test = subtract_dict(curr_dict, dict_to_update)
assert test == {"translation": {"translations": {"language": Ellipsis}}}
def test_subtracting_dict_inc_set_with_dict_inc_set():
curr_dict = {
"aa": Ellipsis,
"bb": Ellipsis,
"cc": {
"aa": {"xx", "yy"},
"bb": Ellipsis
},
"dd": {"aa", "bb"},
}
dict_to_update = {
"aa": Ellipsis,
"bb": {"cc", "dd"},
"cc": {
"aa": {"xx", "oo", "zz", "ii"}
},
"dd": {"aa", "bb"},
}
test = subtract_dict(curr_dict, dict_to_update)
assert test == {"cc": {"aa": {"yy"}, "bb": Ellipsis}}
async def save_related( # noqa: CCR001
self,
follow: bool = False,
save_all: bool = False,
relation_map: Dict = None,
exclude: Union[Set, Dict] = None,
update_count: int = 0,
) -> int:
"""
Triggers a upsert method on all related models
if the instances are not already saved.
By default saves only the directly related ones.
If follow=True is set it saves also related models of related models.
To not get stuck in an infinite loop as related models also keep a relation
to parent model visited models set is kept.
That way already visited models that are nested are saved, but the save do not
follow them inside. So Model A -> Model B -> Model A -> Model C will save second
Model A but will never follow into Model C.
Nested relations of those kind need to be persisted manually.
:param exclude: items to exclude during saving of relations
:type exclude: Union[Set, Dict]
:param relation_map: map of relations to follow
:type relation_map: Dict
:param save_all: flag if all models should be saved or only not saved ones
:type save_all: bool
:param follow: flag to trigger deep save -
by default only directly related models are saved
with follow=True also related models of related models are saved
:type follow: bool
:param update_count: internal parameter for recursive calls -
number of updated instances
:type update_count: int
:return: number of updated/saved models
:rtype: int
"""
relation_map = (
relation_map
if relation_map is not None
else translate_list_to_dict(self._iterate_related_models())
)
if exclude and isinstance(exclude, Set):
exclude = translate_list_to_dict(exclude)
relation_map = subtract_dict(relation_map, exclude or {})
for related in self.extract_related_names():
if relation_map and related in relation_map:
value = getattr(self, related)
if value:
update_count = await self._update_and_follow(
value=value,
follow=follow,
save_all=save_all,
relation_map=self._skip_ellipsis( # type: ignore
relation_map, related, default_return={}
),
update_count=update_count,
)
return update_count
async def save_related( # noqa: CCR001
self,
follow: bool = False,
save_all: bool = False,
relation_map: Dict = None,
exclude: Union[Set, Dict] = None,
update_count: int = 0,
previous_model: "Model" = None,
relation_field: Optional["ForeignKeyField"] = None,
) -> int:
"""
Triggers a upsert method on all related models
if the instances are not already saved.
By default saves only the directly related ones.
If follow=True is set it saves also related models of related models.
To not get stuck in an infinite loop as related models also keep a relation
to parent model visited models set is kept.
That way already visited models that are nested are saved, but the save do not
follow them inside. So Model A -> Model B -> Model A -> Model C will save second
Model A but will never follow into Model C.
Nested relations of those kind need to be persisted manually.
:param relation_field: field with relation leading to this model
:type relation_field: Optional[ForeignKeyField]
:param previous_model: previous model from which method came
:type previous_model: Model
:param exclude: items to exclude during saving of relations
:type exclude: Union[Set, Dict]
:param relation_map: map of relations to follow
:type relation_map: Dict
:param save_all: flag if all models should be saved or only not saved ones
:type save_all: bool
:param follow: flag to trigger deep save -
by default only directly related models are saved
with follow=True also related models of related models are saved
:type follow: bool
:param update_count: internal parameter for recursive calls -
number of updated instances
:type update_count: int
:return: number of updated/saved models
:rtype: int
"""
relation_map = (relation_map if relation_map is not None else
translate_list_to_dict(self._iterate_related_models()))
if exclude and isinstance(exclude, Set):
exclude = translate_list_to_dict(exclude)
relation_map = subtract_dict(relation_map, exclude or {})
if relation_map:
fields_to_visit = {
field
for field in self.extract_related_fields()
if field.name in relation_map
}
pre_save = {
field
for field in fields_to_visit
if not field.virtual and not field.is_multi
}
update_count = await self._update_relation_list(
fields_list=pre_save,
follow=follow,
save_all=save_all,
relation_map=relation_map,
update_count=update_count,
)
update_count = await self._upsert_model(
instance=self,
save_all=save_all,
previous_model=previous_model,
relation_field=relation_field,
update_count=update_count,
)
post_save = fields_to_visit - pre_save
update_count = await self._update_relation_list(
fields_list=post_save,
follow=follow,
save_all=save_all,
relation_map=relation_map,
update_count=update_count,
)
else:
update_count = await self._upsert_model(
instance=self,
save_all=save_all,
previous_model=previous_model,
relation_field=relation_field,
update_count=update_count,
)
return update_count