libervia-backend: sat/plugins/plugin_misc

comparison sat/plugins/plugin_misc_identity.py @ 4037:524856bd7b19

massive refactoring to switch from camelCase to snake_case: historically, Libervia (SàT before) was using camelCase as allowed by PEP8 when using a pre-PEP8 code, to use the same coding style as in Twisted. However, snake_case is more readable and it's better to follow PEP8 best practices, so it has been decided to move on full snake_case. Because Libervia has a huge codebase, this ended with a ugly mix of camelCase and snake_case. To fix that, this patch does a big refactoring by renaming every function and method (including bridge) that are not coming from Twisted or Wokkel, to use fully snake_case. This is a massive change, and may result in some bugs.

author	Goffi <goffi@goffi.org>
date	Sat, 08 Apr 2023 13:54:42 +0200
parents	998c5318230f
children

comparison

equal deleted inserted replaced

-:c4464d7ae97b
+:524856bd7b19
 self._m = host.plugins.get("XEP-0045")
 self.metadata = {
 "avatar": {
 "type": dict,
 # convert avatar path to avatar metadata (and check validity)
-"set_data_filter": self.avatarSetDataFilter,
+"set_data_filter": self.avatar_set_data_filter,
 # update profile avatar, so all frontends are aware
-"set_post_treatment": self.avatarSetPostTreatment,
+"set_post_treatment": self.avatar_set_post_treatment,
-"update_is_new_data": self.avatarUpdateIsNewData,
+"update_is_new_data": self.avatar_update_is_new_data,
-"update_data_filter": self.avatarUpdateDataFilter,
+"update_data_filter": self.avatar_update_data_filter,
 # we store the metadata in database, to restore it on next connection
 # (it is stored only for roster entities)
 "store": True,
 },
 "nicknames": {
 "type": list,
 # accumulate all nicknames from all callbacks in a list instead
 # of returning only the data from the first successful callback
 "get_all": True,
 # append nicknames from roster, resource, etc.
-"get_post_treatment": self.nicknamesGetPostTreatment,
+"get_post_treatment": self.nicknames_get_post_treatment,
-"update_is_new_data": self.nicknamesUpdateIsNewData,
+"update_is_new_data": self.nicknames_update_is_new_data,
 "store": True,
 },
 "description": {
 "type": str,
 "get_all": True,
-"get_post_treatment": self.descriptionGetPostTreatment,
+"get_post_treatment": self.description_get_post_treatment,
 "store": True,
 }
 }
-host.trigger.add("roster_update", self._rosterUpdateTrigger)
+host.trigger.add("roster_update", self._roster_update_trigger)
-host.memory.setSignalOnUpdate("avatar")
+host.memory.set_signal_on_update("avatar")
-host.memory.setSignalOnUpdate("nicknames")
+host.memory.set_signal_on_update("nicknames")
-host.bridge.addMethod(
+host.bridge.add_method(
-"identityGet",
+"identity_get",
 ".plugin",
 in_sign="sasbs",
 out_sign="s",
-method=self._getIdentity,
+method=self._get_identity,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"identitiesGet",
+"identities_get",
 ".plugin",
 in_sign="asass",
 out_sign="s",
-method=self._getIdentities,
+method=self._get_identities,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"identitiesBaseGet",
+"identities_base_get",
 ".plugin",
 in_sign="s",
 out_sign="s",
-method=self._getBaseIdentities,
+method=self._get_base_identities,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"identitySet",
+"identity_set",
 ".plugin",
 in_sign="ss",
 out_sign="",
-method=self._setIdentity,
+method=self._set_identity,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"avatarGet",
+"avatar_get",
 ".plugin",
 in_sign="sbs",
 out_sign="s",
 method=self._getAvatar,
 async_=True,
 )
-host.bridge.addMethod(
+host.bridge.add_method(
-"avatarSet",
+"avatar_set",
 ".plugin",
 in_sign="sss",
 out_sign="",
-method=self._setAvatar,
+method=self._set_avatar,
 async_=True,
 )
-async def profileConnecting(self, client):
+async def profile_connecting(self, client):
 client._identity_update_lock = []
 # we restore known identities from database
 client._identity_storage = persistent.LazyPersistentBinaryDict(
 "identity", client.profile)
 log.warning(
 f"invalid data for {entity} avatar, it will be deleted: "
 f"{value}")
 to_delete.append(key)
 continue
-cache = self.host.common_cache.getMetadata(cache_uid)
+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")
 to_delete.append(key)
 continue
-self.host.memory.updateEntityData(
+self.host.memory.update_entity_data(
 client, entity, name, value, silent=True
 )
 for key in to_delete:
 await client._identity_storage.adel(key)
-def _rosterUpdateTrigger(self, client, roster_item):
+def _roster_update_trigger(self, client, roster_item):
-old_item = client.roster.getItem(roster_item.jid)
+old_item = client.roster.get_item(roster_item.jid)
 if old_item is None or old_item.name != roster_item.name:
 log.debug(
 f"roster nickname has been updated to {roster_item.name!r} for "
 f"{roster_item.jid}"
 )
 callback = Callback(origin=origin, get=cb_get, set=cb_set, priority=priority)
 cb_list = self.metadata[metadata_name].setdefault('callbacks', [])
 cb_list.append(callback)
 cb_list.sort(key=lambda c: c.priority, reverse=True)
-def getIdentityJid(self, client, peer_jid):
+def get_identity_jid(self, client, peer_jid):
 """Return jid to use to set identity metadata
 if it's a jid of a room occupant, full jid will be used
 otherwise bare jid will be used
 if None, bare jid of profile will be used
 if peer_jid is None:
 return client.jid.userhostJID()
 if self._m is None:
 return peer_jid.userhostJID()
 else:
-return self._m.getBareOrFull(client, peer_jid)
+return self._m.get_bare_or_full(client, peer_jid)
-def checkType(self, metadata_name, value):
+def check_type(self, metadata_name, value):
 """Check that type used for a metadata is the one declared in self.metadata"""
 value_type = self.metadata[metadata_name]["type"]
 if not isinstance(value, value_type):
 raise ValueError(
 f"{value} has wrong type: it is {type(value)} while {value_type} was "
 f"expected")
-def getFieldType(self, metadata_name: str) -> str:
+def get_field_type(self, metadata_name: str) -> str:
 """Return the type the requested field
 @param metadata_name: name of the field to check
 @raise KeyError: the request field doesn't exist
 """
 @param entity: entity for which avatar is requested
 None to use profile's jid
 @param use_cache: if False, cache won't be checked
 @param prefilled_values: map of origin => value to use when `get_all` is set
 """
-entity = self.getIdentityJid(client, entity)
+entity = self.get_identity_jid(client, entity)
 try:
 metadata = self.metadata[metadata_name]
 except KeyError:
 raise ValueError(f"Invalid metadata name: {metadata_name!r}")
 get_all = metadata.get('get_all', False)
 if use_cache:
 try:
-data = self.host.memory.getEntityDatum(
+data = self.host.memory.get_entity_datum(
 client, entity, metadata_name)
 except (KeyError, exceptions.UnknownEntityError):
 pass
 else:
 return data
 log.warning(
 _("Error while trying to get {metadata_name} with {callback}: {e}")
 .format(callback=callback.get, metadata_name=metadata_name, e=e))
 else:
 if data:
-self.checkType(metadata_name, data)
+self.check_type(metadata_name, data)
 if get_all:
 if isinstance(data, list):
 all_data.extend(data)
 else:
 all_data.append(data)
 if get_all:
 data = all_data
 post_treatment = metadata.get("get_post_treatment")
 if post_treatment is not None:
-data = await utils.asDeferred(post_treatment, client, entity, data)
+data = await utils.as_deferred(post_treatment, client, entity, data)
-self.host.memory.updateEntityData(
+self.host.memory.update_entity_data(
 client, entity, metadata_name, data)
 if metadata.get('store', False):
 key = f"{entity}\n{metadata_name}"
 await client._identity_storage.aset(key, data)
 the name will also be used to set entity data in host.memory
 @param data(object): value to set
 @param entity(jid.JID, None): entity for which avatar is requested
 None to use profile's jid
 """
-entity = self.getIdentityJid(client, entity)
+entity = self.get_identity_jid(client, entity)
 metadata = self.metadata[metadata_name]
 data_filter = metadata.get("set_data_filter")
 if data_filter is not None:
-data = await utils.asDeferred(data_filter, client, entity, data)
+data = await utils.as_deferred(data_filter, client, entity, data)
-self.checkType(metadata_name, data)
+self.check_type(metadata_name, data)
 try:
 callbacks = metadata['callbacks']
 except KeyError:
 log.warning(_("No callback registered for {metadata_name}")
 else:
 raise exceptions.FeatureNotFound(f"Can't set {metadata_name} for {entity}")
 post_treatment = metadata.get("set_post_treatment")
 if post_treatment is not None:
-await utils.asDeferred(post_treatment, client, entity, data)
+await utils.as_deferred(post_treatment, client, entity, data)
 async def update(
 self,
 client: SatXMPPEntity,
 origin: str,
 """Update a metadata in cache
 This method may be called by plugins when an identity metadata is available.
 @param origin: namespace of the plugin which is source of the metadata
 """
-entity = self.getIdentityJid(client, entity)
+entity = self.get_identity_jid(client, entity)
 if (entity, metadata_name) in client._identity_update_lock:
 log.debug(f"update is locked for {entity}'s {metadata_name}")
 return
 metadata = self.metadata[metadata_name]
 try:
-cached_data = self.host.memory.getEntityDatum(
+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
 else:
 # metadata is cached, we check if the new value differs from the cached one
 try:
 update_is_new_data = metadata["update_is_new_data"]
 except KeyError:
-update_is_new_data = self.defaultUpdateIsNewData
+update_is_new_data = self.default_update_is_new_data
 if data is None:
 if cached_data is None:
 log.debug(
 f"{metadata_name} for {entity} is already disabled, nothing to "
 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:
-self.host.memory.delEntityDatum(client, entity, metadata_name)
+self.host.memory.del_entity_datum(client, entity, metadata_name)
 except (KeyError, exceptions.UnknownEntityError):
 pass
 # then fill it again by calling get, which will retrieve all values
 # we lock update to avoid infinite recursions (update can be called during
 # get callbacks)
 return
 if data is not None:
 data_filter = metadata['update_data_filter']
 if data_filter is not None:
-data = await utils.asDeferred(data_filter, client, entity, data)
+data = await utils.as_deferred(data_filter, client, entity, data)
-self.checkType(metadata_name, data)
+self.check_type(metadata_name, data)
-self.host.memory.updateEntityData(client, entity, metadata_name, data)
+self.host.memory.update_entity_data(client, entity, metadata_name, data)
 if metadata.get('store', False):
 key = f"{entity}\n{metadata_name}"
 await client._identity_storage.aset(key, data)
-def defaultUpdateIsNewData(self, client, entity, cached_data, new_data):
+def default_update_is_new_data(self, client, entity, cached_data, new_data):
 return new_data != cached_data
 def _getAvatar(self, entity, use_cache, profile):
-client = self.host.getClient(profile)
+client = self.host.get_client(profile)
 entity = jid.JID(entity) if entity else None
 d = defer.ensureDeferred(self.get(client, "avatar", entity, use_cache))
 d.addCallback(lambda data: data_format.serialise(data))
 return d
-def _setAvatar(self, file_path, entity, profile_key=C.PROF_KEY_NONE):
+def _set_avatar(self, file_path, entity, profile_key=C.PROF_KEY_NONE):
-client = self.host.getClient(profile_key)
+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))
-def _blockingCacheAvatar(
+def _blocking_cache_avatar(
 self,
 source: str,
 avatar_data: dict[str, Any]
 ):
 """This method is executed in a separated thread"""
 media_type = avatar_data["media_type"]
 avatar_data["base64"] = image_b64 = b64encode(img_buf.read()).decode()
 img_buf.seek(0)
 image_hash = hashlib.sha1(img_buf.read()).hexdigest()
 img_buf.seek(0)
-with self.host.common_cache.cacheData(
+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
-async def cacheAvatar(self, source: str, avatar_data: Dict[str, Any]) -> None:
+async def cache_avatar(self, source: str, avatar_data: Dict[str, Any]) -> None:
 """Resize if necessary and cache avatar
 @param source: source importing the avatar (usually it is plugin's import name),
 will be used in cache metadata
-@param avatar_data: avatar metadata as build by [avatarSetDataFilter]
+@param avatar_data: avatar metadata as build by [avatar_set_data_filter]
 will be updated with following keys:
 path: updated path using cached file
 filename: updated filename using cached file
 base64: resized and base64 encoded avatar
 cache_uid: SHA1 hash used as cache unique ID
 """
-await threads.deferToThread(self._blockingCacheAvatar, source, avatar_data)
+await threads.deferToThread(self._blocking_cache_avatar, source, avatar_data)
-async def avatarSetDataFilter(self, client, entity, file_path):
+async def avatar_set_data_filter(self, client, entity, file_path):
 """Convert avatar file path to dict data"""
 file_path = Path(file_path)
 if not file_path.is_file():
 raise ValueError(f"There is no file at {file_path} to use as avatar")
 avatar_data = {
 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/'):
 raise ValueError(f"File at {file_path} doesn't appear to be an image")
-await self.cacheAvatar(IMPORT_NAME, avatar_data)
+await self.cache_avatar(IMPORT_NAME, avatar_data)
 return avatar_data
-async def avatarSetPostTreatment(self, client, entity, avatar_data):
+async def avatar_set_post_treatment(self, client, entity, avatar_data):
 """Update our own avatar"""
 await self.update(client, IMPORT_NAME, "avatar", avatar_data, entity)
-def avatarBuildMetadata(
+def avatar_build_metadata(
 self,
 path: Path,
 media_type: Optional[str] = None,
 cache_uid: Optional[str] = None
 ) -> Optional[Dict[str, Union[str, Path, None]]]:
 "filename": path.name,
 "media_type": media_type,
 "cache_uid": cache_uid,
 }
-def avatarUpdateIsNewData(self, client, entity, cached_data, new_data):
+def avatar_update_is_new_data(self, client, entity, cached_data, new_data):
 return new_data['path'] != cached_data['path']
-async def avatarUpdateDataFilter(self, client, entity, data):
+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'}
 if not data.keys() >= mandatory_keys:
 raise ValueError(f"missing avatar data keys: {mandatory_keys - data.keys()}")
 return data
-async def nicknamesGetPostTreatment(self, client, entity, plugin_nicknames):
+async def nicknames_get_post_treatment(self, client, entity, plugin_nicknames):
 """Prepend nicknames from core locations + set default nickname
 nicknames are checked from many locations, there is always at least
 one nickname. First nickname of the list can be used in priority.
 Nicknames are appended in this order:
 """
 nicknames = []
 # for MUC we add resource
 if entity.resource:
-# getIdentityJid let the resource only if the entity is a MUC room
+# get_identity_jid let the resource only if the entity is a MUC room
 # occupant jid
 nicknames.append(entity.resource)
 # we first check roster (if we are not in a component)
 if not client.is_component:
-roster_item = client.roster.getItem(entity.userhostJID())
+roster_item = client.roster.get_item(entity.userhostJID())
 if roster_item is not None and roster_item.name:
 # user set name has priority over entity set name
 nicknames.append(roster_item.name)
 nicknames.extend(plugin_nicknames)
 nicknames.append(entity.userhost())
 # we remove duplicates while preserving order with dict
 return list(dict.fromkeys(nicknames))
-def nicknamesUpdateIsNewData(self, client, entity, cached_data, new_nicknames):
+def nicknames_update_is_new_data(self, client, entity, cached_data, new_nicknames):
 return not set(new_nicknames).issubset(cached_data)
-async def descriptionGetPostTreatment(
+async def description_get_post_treatment(
 self,
 client: SatXMPPEntity,
 entity: jid.JID,
 plugin_description: List[str]
 ) -> str:
 """Join all descriptions in a unique string"""
 return '\n'.join(plugin_description)
-def _getIdentity(self, entity_s, metadata_filter, use_cache, profile):
+def _get_identity(self, entity_s, metadata_filter, use_cache, profile):
 entity = jid.JID(entity_s)
-client = self.host.getClient(profile)
+client = self.host.get_client(profile)
 d = defer.ensureDeferred(
-self.getIdentity(client, entity, metadata_filter, use_cache))
+self.get_identity(client, entity, metadata_filter, use_cache))
 d.addCallback(data_format.serialise)
 return d
-async def getIdentity(
+async def get_identity(
 self,
 client: SatXMPPEntity,
 entity: Optional[jid.JID] = None,
 metadata_filter: Optional[List[str]] = None,
 use_cache: bool = True
 id_data[metadata_name] = await self.get(
 client, metadata_name, entity, use_cache)
 return id_data
-def _getIdentities(self, entities_s, metadata_filter, profile):
+def _get_identities(self, entities_s, metadata_filter, profile):
 entities = [jid.JID(e) for e in entities_s]
-client = self.host.getClient(profile)
+client = self.host.get_client(profile)
-d = defer.ensureDeferred(self.getIdentities(client, entities, metadata_filter))
+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()}))
 return d
-async def getIdentities(
+async def get_identities(
 self,
 client: SatXMPPEntity,
 entities: List[jid.JID],
 metadata_filter: Optional[List[str]] = None,
 ) -> dict:
 """Retrieve several identities at once
 @param entities: entities from which identities must be retrieved
-@param metadata_filter: same as for [getIdentity]
+@param metadata_filter: same as for [get_identity]
 @return: identities metadata where key is jid
 if an error happens while retrieve a jid entity, it won't be present in the
 result (and a warning will be logged)
 """
 identities = {}
 get_identity_list = []
 for entity_jid in entities:
 get_identity_list.append(
 defer.ensureDeferred(
-self.getIdentity(
+self.get_identity(
 client,
 entity=entity_jid,
 metadata_filter=metadata_filter,
 )
 )
 log.warning(f"Can't get identity for {entity_jid}")
 else:
 identities[entity_jid] = identity
 return identities
-def _getBaseIdentities(self, profile_key):
+def _get_base_identities(self, profile_key):
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
-d = defer.ensureDeferred(self.getBaseIdentities(client))
+d = defer.ensureDeferred(self.get_base_identities(client))
 d.addCallback(lambda d: data_format.serialise({str(j):i for j, i in d.items()}))
 return d
-async def getBaseIdentities(
+async def get_base_identities(
 self,
 client: SatXMPPEntity,
 ) -> dict:
 """Retrieve identities for entities in roster + own identity + invitations
 """
 if client.is_component:
 entities = [client.jid.userhostJID()]
 else:
-entities = client.roster.getJids() + [client.jid.userhostJID()]
+entities = client.roster.get_jids() + [client.jid.userhostJID()]
-return await self.getIdentities(
+return await self.get_identities(
 client,
 entities,
 ['avatar', 'nicknames']
 )
-def _setIdentity(self, id_data_s, profile):
+def _set_identity(self, id_data_s, profile):
-client = self.host.getClient(profile)
+client = self.host.get_client(profile)
 id_data = data_format.deserialise(id_data_s)
-return defer.ensureDeferred(self.setIdentity(client, id_data))
+return defer.ensureDeferred(self.set_identity(client, id_data))
-async def setIdentity(self, client, id_data):
+async def set_identity(self, client, id_data):
 """Update profile's identity
 @param id_data(dict): data to update, key can be one of self.metadata keys
 """
 if not id_data.keys() <= self.metadata.keys():

Mercurial > libervia-backend

comparison sat/plugins/plugin_misc_identity.py @ 4037:524856bd7b19