Reformatted code base using black.

This commit is contained in:
Goffi 2024-06-19 18:44:57 +02:00
commit 53fdaa9d09

View file

@ -43,7 +43,6 @@ except:
)
log = getLogger(__name__)
@ -86,7 +85,7 @@ class Identity:
# (it is stored only for roster entities)
"store": True,
"store_serialisation": self._avatar_ser,
"store_deserialisation": self._avatar_deser
"store_deserialisation": self._avatar_deser,
},
"nicknames": {
"type": list,
@ -103,7 +102,7 @@ class Identity:
"get_all": True,
"get_post_treatment": self.description_get_post_treatment,
"store": True,
}
},
}
host.trigger.add("roster_update", self._roster_update_trigger)
host.memory.set_signal_on_update("avatar")
@ -161,14 +160,15 @@ class Identity:
client._identity_update_lock = []
# we restore known identities from database
client._identity_storage = persistent.LazyPersistentBinaryDict(
"identity", client.profile)
"identity", client.profile
)
stored_data = await client._identity_storage.all()
to_delete = []
for key, value in stored_data.items():
entity_s, name = key.split('\n')
entity_s, name = key.split("\n")
try:
metadata = self.metadata[name]
except KeyError:
@ -181,31 +181,31 @@ class Identity:
value = deser_method(value)
entity = jid.JID(entity_s)
if name == 'avatar':
if name == "avatar":
if value is not None:
try:
cache_uid = value['cache_uid']
cache_uid = value["cache_uid"]
if not cache_uid:
raise ValueError
filename = value['filename']
filename = value["filename"]
if not filename:
raise ValueError
except (ValueError, KeyError):
log.warning(
f"invalid data for {entity} avatar, it will be deleted: "
f"{value}")
f"{value}"
)
to_delete.append(key)
continue
cache = self.host.common_cache.get_metadata(cache_uid)
if cache is None:
log.debug(
f"purging avatar for {entity}: it is not in cache anymore")
f"purging avatar for {entity}: it is not in cache anymore"
)
to_delete.append(key)
continue
self.host.memory.update_entity_data(
client, entity, name, value, silent=True
)
self.host.memory.update_entity_data(client, entity, name, value, silent=True)
for key in to_delete:
await client._identity_storage.adel(key)
@ -219,22 +219,19 @@ class Identity:
)
defer.ensureDeferred(
self.update(
client,
IMPORT_NAME,
"nicknames",
[roster_item.name],
roster_item.jid
client, IMPORT_NAME, "nicknames", [roster_item.name], roster_item.jid
)
)
return True
def register(
self,
origin: str,
metadata_name: str,
cb_get: Union[Coroutine, defer.Deferred],
cb_set: Union[Coroutine, defer.Deferred],
priority: int=0):
self,
origin: str,
metadata_name: str,
cb_get: Union[Coroutine, defer.Deferred],
cb_set: Union[Coroutine, defer.Deferred],
priority: int = 0,
):
"""Register callbacks to handle identity metadata
@param origin: namespace of the plugin managing this metadata
@ -251,7 +248,7 @@ class Identity:
if not metadata_name in self.metadata.keys():
raise ValueError(f"Invalid metadata_name: {metadata_name!r}")
callback = Callback(origin=origin, get=cb_get, set=cb_set, priority=priority)
cb_list = self.metadata[metadata_name].setdefault('callbacks', [])
cb_list = self.metadata[metadata_name].setdefault("callbacks", [])
cb_list.append(callback)
cb_list.sort(key=lambda c: c.priority, reverse=True)
@ -276,7 +273,8 @@ class Identity:
if not isinstance(value, value_type):
raise ValueError(
f"{value} has wrong type: it is {type(value)} while {value_type} was "
f"expected")
f"expected"
)
def get_field_type(self, metadata_name: str) -> str:
"""Return the type the requested field
@ -287,13 +285,13 @@ class Identity:
return self.metadata[metadata_name]["type"]
async def get(
self,
client: SatXMPPEntity,
metadata_name: str,
entity: Optional[jid.JID],
use_cache: bool=True,
prefilled_values: Optional[Dict[str, Any]]=None
):
self,
client: SatXMPPEntity,
metadata_name: str,
entity: Optional[jid.JID],
use_cache: bool = True,
prefilled_values: Optional[Dict[str, Any]] = None,
):
"""Retrieve identity metadata of an entity
if metadata is already in cache, it is returned. Otherwise, registered callbacks
@ -311,28 +309,31 @@ class Identity:
metadata = self.metadata[metadata_name]
except KeyError:
raise ValueError(f"Invalid metadata name: {metadata_name!r}")
get_all = metadata.get('get_all', False)
get_all = metadata.get("get_all", False)
if use_cache:
try:
data = self.host.memory.get_entity_datum(
client, entity, metadata_name)
data = self.host.memory.get_entity_datum(client, entity, metadata_name)
except (KeyError, exceptions.UnknownEntityError):
pass
else:
return data
try:
callbacks = metadata['callbacks']
callbacks = metadata["callbacks"]
except KeyError:
log.warning(_("No callback registered for {metadata_name}")
.format(metadata_name=metadata_name))
log.warning(
_("No callback registered for {metadata_name}").format(
metadata_name=metadata_name
)
)
return [] if get_all else None
if get_all:
all_data = []
elif prefilled_values is not None:
raise exceptions.InternalError(
"prefilled_values can only be used when `get_all` is set")
"prefilled_values can only be used when `get_all` is set"
)
for callback in callbacks:
try:
@ -340,15 +341,18 @@ class Identity:
data = prefilled_values[callback.origin]
log.debug(
f"using prefilled values {data!r} for {metadata_name} with "
f"{callback.origin}")
f"{callback.origin}"
)
else:
data = await defer.ensureDeferred(callback.get(client, entity))
except exceptions.CancelError:
continue
except Exception as e:
log.warning(
_("Error while trying to get {metadata_name} with {callback}: {e}")
.format(callback=callback.get, metadata_name=metadata_name, e=e))
_(
"Error while trying to get {metadata_name} with {callback}: {e}"
).format(callback=callback.get, metadata_name=metadata_name, e=e)
)
else:
if data:
self.check_type(metadata_name, data)
@ -369,10 +373,9 @@ class Identity:
if post_treatment is not None:
data = await utils.as_deferred(post_treatment, client, entity, data)
self.host.memory.update_entity_data(
client, entity, metadata_name, data)
self.host.memory.update_entity_data(client, entity, metadata_name, data)
if metadata.get('store', False):
if metadata.get("store", False):
if data is not None:
ser_method = metadata.get("store_serialisation")
if ser_method is not None:
@ -401,10 +404,13 @@ class Identity:
self.check_type(metadata_name, data)
try:
callbacks = metadata['callbacks']
callbacks = metadata["callbacks"]
except KeyError:
log.warning(_("No callback registered for {metadata_name}")
.format(metadata_name=metadata_name))
log.warning(
_("No callback registered for {metadata_name}").format(
metadata_name=metadata_name
)
)
return exceptions.FeatureNotFound(f"Can't set {metadata_name} for {entity}")
for callback in callbacks:
@ -414,8 +420,10 @@ class Identity:
continue
except Exception as e:
log.warning(
_("Error while trying to set {metadata_name} with {callback}: {e}")
.format(callback=callback.set, metadata_name=metadata_name, e=e))
_(
"Error while trying to set {metadata_name} with {callback}: {e}"
).format(callback=callback.set, metadata_name=metadata_name, e=e)
)
else:
break
else:
@ -431,7 +439,7 @@ class Identity:
origin: str,
metadata_name: str,
data: Any,
entity: Optional[jid.JID]
entity: Optional[jid.JID],
):
"""Update a metadata in cache
@ -445,8 +453,7 @@ class Identity:
metadata = self.metadata[metadata_name]
try:
cached_data = self.host.memory.get_entity_datum(
client, entity, metadata_name)
cached_data = self.host.memory.get_entity_datum(client, entity, metadata_name)
except (KeyError, exceptions.UnknownEntityError):
# metadata is not cached, we do the update
pass
@ -461,21 +468,22 @@ class Identity:
if cached_data is None:
log.debug(
f"{metadata_name} for {entity} is already disabled, nothing to "
f"do")
f"do"
)
return
elif cached_data is None:
pass
elif not update_is_new_data(client, entity, cached_data, data):
log.debug(
f"{metadata_name} for {entity} is already in cache, nothing to "
f"do")
f"{metadata_name} for {entity} is already in cache, nothing to " f"do"
)
return
# we can't use the cache, so we do the update
log.debug(f"updating {metadata_name} for {entity}")
if metadata.get('get_all', False):
if metadata.get("get_all", False):
# get_all is set, meaning that we have to check all plugins
# so we first delete current cache
try:
@ -491,14 +499,14 @@ class Identity:
return
if data is not None:
data_filter = metadata['update_data_filter']
data_filter = metadata["update_data_filter"]
if data_filter is not None:
data = await utils.as_deferred(data_filter, client, entity, data)
self.check_type(metadata_name, data)
self.host.memory.update_entity_data(client, entity, metadata_name, data)
if metadata.get('store', False):
if metadata.get("store", False):
key = f"{entity}\n{metadata_name}"
if data is not None:
ser_method = metadata.get("store_serialisation")
@ -519,14 +527,9 @@ class Identity:
def _set_avatar(self, file_path, entity, profile_key=C.PROF_KEY_NONE):
client = self.host.get_client(profile_key)
entity = jid.JID(entity) if entity else None
return defer.ensureDeferred(
self.set(client, "avatar", file_path, entity))
return defer.ensureDeferred(self.set(client, "avatar", file_path, entity))
def _blocking_cache_avatar(
self,
source: str,
avatar_data: dict[str, Any]
):
def _blocking_cache_avatar(self, source: str, avatar_data: dict[str, Any]):
"""This method is executed in a separated thread"""
if avatar_data["media_type"] == "image/svg+xml":
# for vector image, we save directly
@ -562,13 +565,11 @@ class Identity:
img_buf.seek(0)
image_hash = hashlib.sha1(img_buf.read()).hexdigest()
img_buf.seek(0)
with self.host.common_cache.cache_data(
source, image_hash, media_type
) as f:
with self.host.common_cache.cache_data(source, image_hash, media_type) as f:
f.write(img_buf.read())
avatar_data['path'] = Path(f.name)
avatar_data['filename'] = avatar_data['path'].name
avatar_data['cache_uid'] = image_hash
avatar_data["path"] = Path(f.name)
avatar_data["filename"] = avatar_data["path"].name
avatar_data["cache_uid"] = image_hash
async def cache_avatar(self, source: str, avatar_data: Dict[str, Any]) -> None:
"""Resize if necessary and cache avatar
@ -590,14 +591,14 @@ class Identity:
if not file_path.is_file():
raise ValueError(f"There is no file at {file_path} to use as avatar")
avatar_data = {
'path': file_path,
'filename': file_path.name,
'media_type': image.guess_type(file_path),
"path": file_path,
"filename": file_path.name,
"media_type": image.guess_type(file_path),
}
media_type = avatar_data['media_type']
media_type = avatar_data["media_type"]
if media_type is None:
raise ValueError(f"Can't identify type of image at {file_path}")
if not media_type.startswith('image/'):
if not media_type.startswith("image/"):
raise ValueError(f"File at {file_path} doesn't appear to be an image")
await self.cache_avatar(IMPORT_NAME, avatar_data)
return avatar_data
@ -607,10 +608,10 @@ class Identity:
await self.update(client, IMPORT_NAME, "avatar", avatar_data, entity)
def avatar_build_metadata(
self,
path: Path,
media_type: Optional[str] = None,
cache_uid: Optional[str] = None
self,
path: Path,
media_type: Optional[str] = None,
cache_uid: Optional[str] = None,
) -> Optional[Dict[str, Union[str, Path, None]]]:
"""Helper method to generate avatar metadata
@ -639,12 +640,12 @@ class Identity:
}
def avatar_update_is_new_data(self, client, entity, cached_data, new_data):
return new_data['path'] != cached_data['path']
return new_data["path"] != cached_data["path"]
async def avatar_update_data_filter(self, client, entity, data):
if not isinstance(data, dict):
raise ValueError(f"Invalid data type ({type(data)}), a dict is expected")
mandatory_keys = {'path', 'filename', 'cache_uid'}
mandatory_keys = {"path", "filename", "cache_uid"}
if not data.keys() >= mandatory_keys:
raise ValueError(f"missing avatar data keys: {mandatory_keys - data.keys()}")
return data
@ -702,19 +703,17 @@ class Identity:
return not set(new_nicknames).issubset(cached_data)
async def description_get_post_treatment(
self,
client: SatXMPPEntity,
entity: jid.JID,
plugin_description: List[str]
self, client: SatXMPPEntity, entity: jid.JID, plugin_description: List[str]
) -> str:
"""Join all descriptions in a unique string"""
return '\n'.join(plugin_description)
return "\n".join(plugin_description)
def _get_identity(self, entity_s, metadata_filter, use_cache, profile):
entity = jid.JID(entity_s)
client = self.host.get_client(profile)
d = defer.ensureDeferred(
self.get_identity(client, entity, metadata_filter, use_cache))
self.get_identity(client, entity, metadata_filter, use_cache)
)
d.addCallback(data_format.serialise)
return d
@ -723,7 +722,7 @@ class Identity:
client: SatXMPPEntity,
entity: Optional[jid.JID] = None,
metadata_filter: Optional[List[str]] = None,
use_cache: bool = True
use_cache: bool = True,
) -> Dict[str, Any]:
"""Retrieve identity of an entity
@ -743,7 +742,8 @@ class Identity:
for metadata_name in metadata_names:
id_data[metadata_name] = await self.get(
client, metadata_name, entity, use_cache)
client, metadata_name, entity, use_cache
)
return id_data
@ -751,7 +751,7 @@ class Identity:
entities = [jid.JID(e) for e in entities_s]
client = self.host.get_client(profile)
d = defer.ensureDeferred(self.get_identities(client, entities, metadata_filter))
d.addCallback(lambda d: data_format.serialise({str(j):i for j, i in d.items()}))
d.addCallback(lambda d: data_format.serialise({str(j): i for j, i in d.items()}))
return d
async def get_identities(
@ -792,7 +792,7 @@ class Identity:
def _get_base_identities(self, profile_key):
client = self.host.get_client(profile_key)
d = defer.ensureDeferred(self.get_base_identities(client))
d.addCallback(lambda d: data_format.serialise({str(j):i for j, i in d.items()}))
d.addCallback(lambda d: data_format.serialise({str(j): i for j, i in d.items()}))
return d
async def get_base_identities(
@ -809,11 +809,7 @@ class Identity:
else:
entities = client.roster.get_jids() + [client.jid.userhostJID()]
return await self.get_identities(
client,
entities,
['avatar', 'nicknames']
)
return await self.get_identities(client, entities, ["avatar", "nicknames"])
def _set_identity(self, id_data_s, profile):
client = self.host.get_client(profile)
@ -827,11 +823,14 @@ class Identity:
"""
if not id_data.keys() <= self.metadata.keys():
raise ValueError(
f"Invalid metadata names: {id_data.keys() - self.metadata.keys()}")
f"Invalid metadata names: {id_data.keys() - self.metadata.keys()}"
)
for metadata_name, data in id_data.items():
try:
await self.set(client, metadata_name, data)
except Exception as e:
log.warning(
_("Can't set metadata {metadata_name!r}: {reason}")
.format(metadata_name=metadata_name, reason=e))
_("Can't set metadata {metadata_name!r}: {reason}").format(
metadata_name=metadata_name, reason=e
)
)