libervia-backend: sat/memory/params.py comparison

comparison sat/memory/params.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	5f546dd910e0
children

comparison

equal deleted inserted replaced

-:c4464d7ae97b
+:524856bd7b19
 log = getLogger(__name__)
 from twisted.internet import defer
 from twisted.python.failure import Failure
 from twisted.words.xish import domish
 from twisted.words.protocols.jabber import jid
-from sat.tools.xml_tools import paramsXML2XMLUI, getText
+from sat.tools.xml_tools import params_xml_2_xmlui, get_text
 from sat.tools.common import data_format
 from xml.sax.saxutils import quoteattr
 # TODO: params should be rewritten using Twisted directly instead of minidom
 #       general params should be linked to sat.conf and kept synchronised
 #       this need an overall simplification to make maintenance easier
-def createJidElts(jids):
+def create_jid_elts(jids):
 """Generator which return <jid/> elements from jids
 @param jids(iterable[id.jID]): jids to use
 @return (generator[domish.Element]): <jid/> elements
 """
 }
 def load_default_params(self):
 self.dom = minidom.parseString(Params.default_xml.encode("utf-8"))
-def _mergeParams(self, source_node, dest_node):
+def _merge_params(self, source_node, dest_node):
 """Look for every node in source_node and recursively copy them to dest if they don't exists"""
-def getNodesMap(children):
+def get_nodes_map(children):
 ret = {}
 for child in children:
 if child.nodeType == child.ELEMENT_NODE:
 ret[(child.tagName, child.getAttribute("name"))] = child
 return ret
-source_map = getNodesMap(source_node.childNodes)
+source_map = get_nodes_map(source_node.childNodes)
-dest_map = getNodesMap(dest_node.childNodes)
+dest_map = get_nodes_map(dest_node.childNodes)
 source_set = set(source_map.keys())
 dest_set = set(dest_map.keys())
 to_add = source_set.difference(dest_set)
 for node_key in to_add:
 dest_node.appendChild(source_map[node_key].cloneNode(True))
 to_recurse = source_set - to_add
 for node_key in to_recurse:
-self._mergeParams(source_map[node_key], dest_map[node_key])
+self._merge_params(source_map[node_key], dest_map[node_key])
 def load_xml(self, xml_file):
 """Load parameters template from xml file"""
 self.dom = minidom.parse(xml_file)
 default_dom = minidom.parseString(Params.default_xml.encode("utf-8"))
-self._mergeParams(default_dom.documentElement, self.dom.documentElement)
+self._merge_params(default_dom.documentElement, self.dom.documentElement)
-def loadGenParams(self):
+def load_gen_params(self):
 """Load general parameters data from storage
 @return: deferred triggered once params are loaded
 """
-return self.storage.loadGenParams(self.params_gen)
+return self.storage.load_gen_params(self.params_gen)
-def loadIndParams(self, profile, cache=None):
+def load_ind_params(self, profile, cache=None):
 """Load individual parameters
 set self.params cache or a temporary cache
 @param profile: profile to load (*must exist*)
 @param cache: if not None, will be used to store the value, as a short time cache
 @return: deferred triggered once params are loaded
 """
 if cache is None:
 self.params[profile] = {}
-return self.storage.loadIndParams(
+return self.storage.load_ind_params(
 self.params[profile] if cache is None else cache, profile
 )
-def purgeProfile(self, profile):
+def purge_profile(self, profile):
 """Remove cache data of a profile
 @param profile: %(doc_profile)s
 """
 try:
 self.storage = storage
 self.default_profile = None
 self.params = {}
 self.params_gen = {}
-def createProfile(self, profile, component):
+def create_profile(self, profile, component):
 """Create a new profile
 @param profile(unicode): name of the profile
 @param component(unicode): entry point if profile is a component
 @param callback: called when the profile actually exists in database and memory
 @return: a Deferred instance
 """
-if self.storage.hasProfile(profile):
+if self.storage.has_profile(profile):
 log.info(_("The profile name already exists"))
 return defer.fail(exceptions.ConflictError())
 if not self.host.trigger.point("ProfileCreation", profile):
 return defer.fail(exceptions.CancelError())
-return self.storage.createProfile(profile, component or None)
+return self.storage.create_profile(profile, component or None)
-def asyncDeleteProfile(self, profile, force=False):
+def profile_delete_async(self, profile, force=False):
 """Delete an existing profile
 @param profile: name of the profile
 @param force: force the deletion even if the profile is connected.
 To be used for direct calls only (not through the bridge).
 @return: a Deferred instance
 """
-if not self.storage.hasProfile(profile):
+if not self.storage.has_profile(profile):
 log.info(_("Trying to delete an unknown profile"))
 return defer.fail(Failure(exceptions.ProfileUnknownError(profile)))
-if self.host.isConnected(profile):
+if self.host.is_connected(profile):
 if force:
 self.host.disconnect(profile)
 else:
 log.info(_("Trying to delete a connected profile"))
 return defer.fail(Failure(exceptions.ProfileConnected))
-return self.storage.deleteProfile(profile)
+return self.storage.delete_profile(profile)
-def getProfileName(self, profile_key, return_profile_keys=False):
+def get_profile_name(self, profile_key, return_profile_keys=False):
 """return profile according to profile_key
 @param profile_key: profile name or key which can be
 C.PROF_KEY_ALL for all profiles
 C.PROF_KEY_DEFAULT for default profile
 if not default:
 log.info(_("No default profile, returning first one"))
 try:
 default = self.host.memory.memory_data[
 "Profile_default"
-] = self.storage.getProfilesList()[0]
+] = self.storage.get_profiles_list()[0]
 except IndexError:
 log.info(_("No profile exist yet"))
 raise exceptions.ProfileUnknownError(profile_key)
 return (
 default
 )  # FIXME: temporary, must use real default value, and fallback to first one if it doesn't exists
 elif profile_key == C.PROF_KEY_NONE:
 raise exceptions.ProfileNotSetError
 elif return_profile_keys and profile_key in [C.PROF_KEY_ALL]:
 return profile_key  # this value must be managed by the caller
-if not self.storage.hasProfile(profile_key):
+if not self.storage.has_profile(profile_key):
 log.error(_("Trying to access an unknown profile (%s)") % profile_key)
 raise exceptions.ProfileUnknownError(profile_key)
 return profile_key
 def __get_unique_node(self, parent, tag, name):
 # the node already exists
 return node
 # the node is new
 return None
-def updateParams(self, xml, security_limit=C.NO_SECURITY_LIMIT, app=""):
+def update_params(self, xml, security_limit=C.NO_SECURITY_LIMIT, app=""):
 """import xml in parameters, update if the param already exists
 If security_limit is specified and greater than -1, the parameters
 that have a security level greater than security_limit are skipped.
 @param xml: parameters in xml form
 continue
 to_remove_count = (
 0
 )  # count the params to be removed from current category
 for node in cat_node.childNodes:
-if node.nodeName != "param" or not self.checkSecurityLimit(
+if node.nodeName != "param" or not self.check_security_limit(
 node, security_limit
 ):
 to_remove.append(node)
 to_remove_count += 1
 continue
 if app:
 pre_process_app_node(src_parent, security_limit, app)
 import_node(self.dom.documentElement, src_parent)
-def paramsRegisterApp(self, xml, security_limit, app):
+def params_register_app(self, xml, security_limit, app):
 """Register frontend's specific parameters
 If security_limit is specified and greater than -1, the parameters
 that have a security level greater than security_limit are skipped.
 @param xml: XML definition of the parameters to be added
 % {"app": app}
 )
 )
 return
 self.frontends_cache.append(app)
-self.updateParams(xml, security_limit, app)
+self.update_params(xml, security_limit, app)
 log.debug("Frontends parameters registered for %(app)s" % {"app": app})
 def __default_ok(self, value, name, category):
 # FIXME: will not work with individual parameters
-self.setParam(name, value, category)
+self.param_set(name, value, category)
 def __default_ko(self, failure, name, category):
 log.error(
 _("Can't determine default value for [%(category)s/%(name)s]: %(reason)s")
 % {"category": category, "name": name, "reason": str(failure.value)}
 )
-def setDefault(self, name, category, callback, errback=None):
+def set_default(self, name, category, callback, errback=None):
 """Set default value of parameter
 'default_cb' attibute of parameter must be set to 'yes'
 @param name: name of the parameter
 @param category: category of the parameter
 @param errback: must manage the error with args failure, name, category
 """
 # TODO: send signal param update if value changed
 # TODO: manage individual paramaters
 log.debug(
-"setDefault called for %(category)s/%(name)s"
+"set_default called for %(category)s/%(name)s"
 % {"category": category, "name": name}
 )
-node = self._getParamNode(name, category, "@ALL@")
+node = self._get_param_node(name, category, "@ALL@")
 if not node:
 log.error(
 _(
 "Requested param [%(name)s] in category [%(category)s] doesn't exist !"
 )
 % {"name": name, "category": category}
 )
 return
 if node[1].getAttribute("default_cb") == "yes":
 # del node[1].attributes['default_cb'] # default_cb is not used anymore as a flag to know if we have to set the default value,
-# and we can still use it later e.g. to call a generic setDefault method
+# and we can still use it later e.g. to call a generic set_default method
-value = self._getParam(category, name, C.GENERAL)
+value = self._get_param(category, name, C.GENERAL)
 if value is None:  # no value set by the user: we have the default value
 log.debug("Default value to set, using callback")
 d = defer.maybeDeferred(callback)
 d.addCallback(self.__default_ok, name, category)
 d.addErrback(errback or self.__default_ko, name, category)
-def _getAttr_internal(self, node, attr, value):
+def _get_attr_internal(self, node, attr, value):
 """Get attribute value.
 /!\ This method would return encrypted password values.
 @param node: XML param node
 if value_to_use:
 jids = value_to_use.split(
 "\t"
 )  # FIXME: it's not good to use tabs as separator !
 else:  # no user defined value, take default value from the XML
-jids = [getText(jid_) for jid_ in node.getElementsByTagName("jid")]
+jids = [get_text(jid_) for jid_ in node.getElementsByTagName("jid")]
 to_delete = []
 for idx, value in enumerate(jids):
 try:
 jids[idx] = jid.JID(value)
 except (RuntimeError, jid.InvalidFormat, AttributeError):
 jids.remove(value)
 return jids
 return value_to_use
 return node.getAttribute(attr)
-def _getAttr(self, node, attr, value):
+def _get_attr(self, node, attr, value):
 """Get attribute value (synchronous).
 /!\ This method can not be used to retrieve password values.
 @param node: XML param node
 @param attr: name of the attribute to get (e.g.: 'value' or 'type')
 @param value: user defined value
 @return (unicode, bool, int, list): value to retrieve
 """
 if attr == "value" and node.getAttribute("type") == "password":
 raise exceptions.InternalError(
-"To retrieve password values, use _asyncGetAttr instead of _getAttr"
+"To retrieve password values, use _async_get_attr instead of _get_attr"
 )
-return self._getAttr_internal(node, attr, value)
+return self._get_attr_internal(node, attr, value)
-def _asyncGetAttr(self, node, attr, value, profile=None):
+def _async_get_attr(self, node, attr, value, profile=None):
 """Get attribute value.
 Profile passwords are returned hashed (if not empty),
 other passwords are returned decrypted (if not empty).
 @param node: XML param node
 @param attr: name of the attribute to get (e.g.: 'value' or 'type')
 @param value: user defined value
 @param profile: %(doc_profile)s
 @return (unicode, bool, int, list): Deferred value to retrieve
 """
-value = self._getAttr_internal(node, attr, value)
+value = self._get_attr_internal(node, attr, value)
 if attr != "value" or node.getAttribute("type") != "password":
 return defer.succeed(value)
 param_cat = node.parentNode.getAttribute("name")
 param_name = node.getAttribute("name")
 if ((param_cat, param_name) == C.PROFILE_PASS_PATH) or not value:
 )  # profile password and empty passwords are returned "as is"
 if not profile:
 raise exceptions.ProfileNotSetError(
 "The profile is needed to decrypt a password"
 )
-password = self.host.memory.decryptValue(value, profile)
+password = self.host.memory.decrypt_value(value, profile)
 if password is None:
 raise exceptions.InternalError("password should never be None")
 return defer.succeed(password)
 def _type_to_str(self, result):
 """Convert result to string, according to its type """
 if isinstance(result, bool):
-return C.boolConst(result)
+return C.bool_const(result)
 elif isinstance(result, (list, set, tuple)):
 return ', '.join(self._type_to_str(r) for r in result)
 else:
 return str(result)
-def getStringParamA(self, name, category, attr="value", profile_key=C.PROF_KEY_NONE):
+def get_string_param_a(self, name, category, attr="value", profile_key=C.PROF_KEY_NONE):
-""" Same as getParamA but for bridge: convert non string value to string """
+""" Same as param_get_a but for bridge: convert non string value to string """
 return self._type_to_str(
-self.getParamA(name, category, attr, profile_key=profile_key)
+self.param_get_a(name, category, attr, profile_key=profile_key)
 )
-def getParamA(
+def param_get_a(
 self, name, category, attr="value", use_default=True, profile_key=C.PROF_KEY_NONE
 ):
 """Helper method to get a specific attribute.
 /!\ This method would return encrypted password values,
-to get the plain values you have to use asyncGetParamA.
+to get the plain values you have to use param_get_a_async.
 @param name: name of the parameter
 @param category: category of the parameter
 @param attr: name of the attribute (default: "value")
 @parm use_default(bool): if True and attr=='value', return default value if not set
 else return None if not set
 @param profile: owner of the param (@ALL@ for everyone)
 @return: attribute
 """
 # FIXME: looks really dirty and buggy, need to be reviewed/refactored
 # FIXME: security_limit is not managed here !
-node = self._getParamNode(name, category)
+node = self._get_param_node(name, category)
 if not node:
 log.error(
 _(
 "Requested param [%(name)s] in category [%(category)s] doesn't exist !"
 )
 )
 raise exceptions.NotFound
 if attr == "value" and node[1].getAttribute("type") == "password":
 raise exceptions.InternalError(
-"To retrieve password values, use asyncGetParamA instead of getParamA"
+"To retrieve password values, use param_get_a_async instead of param_get_a"
 )
 if node[0] == C.GENERAL:
-value = self._getParam(category, name, C.GENERAL)
+value = self._get_param(category, name, C.GENERAL)
 if value is None and attr == "value" and not use_default:
 return value
-return self._getAttr(node[1], attr, value)
+return self._get_attr(node[1], attr, value)
 assert node[0] == C.INDIVIDUAL
-profile = self.getProfileName(profile_key)
+profile = self.get_profile_name(profile_key)
 if not profile:
 log.error(_("Requesting a param for an non-existant profile"))
 raise exceptions.ProfileUnknownError(profile_key)
 if profile not in self.params:
 log.error(_("Requesting synchronous param for not connected profile"))
 raise exceptions.ProfileNotConnected(profile)
 if attr == "value":
-value = self._getParam(category, name, profile=profile)
+value = self._get_param(category, name, profile=profile)
 if value is None and attr == "value" and not use_default:
 return value
-return self._getAttr(node[1], attr, value)
+return self._get_attr(node[1], attr, value)
-async def asyncGetStringParamA(
+async def async_get_string_param_a(
 self, name, category, attr="value", security_limit=C.NO_SECURITY_LIMIT,
 profile=C.PROF_KEY_NONE):
-value = await self.asyncGetParamA(
+value = await self.param_get_a_async(
 name, category, attr, security_limit, profile_key=profile)
 return self._type_to_str(value)
-def asyncGetParamA(
+def param_get_a_async(
 self,
 name,
 category,
 attr="value",
 security_limit=C.NO_SECURITY_LIMIT,
 @param category: category of the parameter
 @param attr: name of the attribute (default: "value")
 @param profile: owner of the param (@ALL@ for everyone)
 @return (defer.Deferred): parameter value, with corresponding type (bool, int, list, etc)
 """
-node = self._getParamNode(name, category)
+node = self._get_param_node(name, category)
 if not node:
 log.error(
 _(
 "Requested param [%(name)s] in category [%(category)s] doesn't exist !"
 )
 % {"name": name, "category": category}
 )
 raise ValueError("Requested param doesn't exist")
-if not self.checkSecurityLimit(node[1], security_limit):
+if not self.check_security_limit(node[1], security_limit):
 log.warning(
 _(
 "Trying to get parameter '%(param)s' in category '%(cat)s' without authorization!!!"
 % {"param": name, "cat": category}
 )
 )
 raise exceptions.PermissionError
 if node[0] == C.GENERAL:
-value = self._getParam(category, name, C.GENERAL)
+value = self._get_param(category, name, C.GENERAL)
-return self._asyncGetAttr(node[1], attr, value)
+return self._async_get_attr(node[1], attr, value)
 assert node[0] == C.INDIVIDUAL
-profile = self.getProfileName(profile_key)
+profile = self.get_profile_name(profile_key)
 if not profile:
 raise exceptions.InternalError(
 _("Requesting a param for a non-existant profile")
 )
 if attr != "value":
 return defer.succeed(node[1].getAttribute(attr))
 try:
-value = self._getParam(category, name, profile=profile)
+value = self._get_param(category, name, profile=profile)
-return self._asyncGetAttr(node[1], attr, value, profile)
+return self._async_get_attr(node[1], attr, value, profile)
 except exceptions.ProfileNotInCacheError:
 # We have to ask data to the storage manager
-d = self.storage.getIndParam(category, name, profile)
+d = self.storage.get_ind_param(category, name, profile)
 return d.addCallback(
-lambda value: self._asyncGetAttr(node[1], attr, value, profile)
+lambda value: self._async_get_attr(node[1], attr, value, profile)
 )
-def _getParamsValuesFromCategory(
+def _get_params_values_from_category(
 self, category, security_limit, app, extra_s, profile_key):
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 extra = data_format.deserialise(extra_s)
-return defer.ensureDeferred(self.getParamsValuesFromCategory(
+return defer.ensureDeferred(self.get_params_values_from_category(
 client, category, security_limit, app, extra))
-async def getParamsValuesFromCategory(
+async def get_params_values_from_category(
 self, client, category, security_limit, app='', extra=None):
 """Get all parameters "attribute" for a category
 @param category(unicode): the desired category
 @param security_limit(int): NO_SECURITY_LIMIT (-1) to return all the params.
 Otherwise sole the params which have a security level defined *and*
 lower or equal to the specified value are returned.
-@param app(str): see [getParams]
+@param app(str): see [get_params]
-@param extra(dict): see [getParams]
+@param extra(dict): see [get_params]
 @return (dict): key: param name, value: param value (converted to string if needed)
 """
 # TODO: manage category of general type (without existant profile)
 if extra is None:
 extra = {}
-prof_xml = await self._constructProfileXml(client, security_limit, app, extra)
+prof_xml = await self._construct_profile_xml(client, security_limit, app, extra)
 ret = {}
 for category_node in prof_xml.getElementsByTagName("category"):
 if category_node.getAttribute("name") == category:
 for param_node in category_node.getElementsByTagName("param"):
 name = param_node.getAttribute("name")
 "ignoring attribute without name: {}".format(
 param_node.toxml()
 )
 )
 continue
-value = await self.asyncGetStringParamA(
+value = await self.async_get_string_param_a(
 name, category, security_limit=security_limit,
 profile=client.profile)
 ret[name] = value
 break
 prof_xml.unlink()
 return ret
-def _getParam(
+def _get_param(
 self, category, name, type_=C.INDIVIDUAL, cache=None, profile=C.PROF_KEY_NONE
 ):
 """Return the param, or None if it doesn't exist
 @param category: param category
 raise exceptions.ProfileNotInCacheError
 if (category, name) not in cache:
 return None
 return cache[(category, name)]
-async def _constructProfileXml(self, client, security_limit, app, extra):
+async def _construct_profile_xml(self, client, security_limit, app, extra):
 """Construct xml for asked profile, filling values when needed
 /!\ as noticed in doc, don't forget to unlink the minidom.Document
 @param security_limit: NO_SECURITY_LIMIT (-1) to return all the params.
 Otherwise sole the params which have a security level defined *and*
 @param profile: profile name (not key !)
 @return: a deferred that fire a minidom.Document of the profile xml (cf warning above)
 """
 profile = client.profile
-def checkNode(node):
+def check_node(node):
 """Check the node against security_limit, app and extra"""
-return (self.checkSecurityLimit(node, security_limit)
+return (self.check_security_limit(node, security_limit)
-and self.checkApp(node, app)
+and self.check_app(node, app)
-and self.checkExtra(node, extra))
+and self.check_extra(node, extra))
 if profile in self.params:
 profile_cache = self.params[profile]
 else:
 # profile is not in cache, we load values in a short time cache
 profile_cache = {}
-await self.loadIndParams(profile, profile_cache)
+await self.load_ind_params(profile, profile_cache)
 # init the result document
 prof_xml = minidom.parseString("<params/>")
 cache = {}
 cache[category] = dest_cat = cat_node.cloneNode(True)
 to_remove = []
 for node in dest_cat.childNodes:
 if node.nodeName != "param":
 continue
-if not checkNode(node):
+if not check_node(node):
 to_remove.append(node)
 continue
 dest_params[node.getAttribute("name")] = node
 for node in to_remove:
 dest_cat.removeChild(node)
 for param_node in params:
 # we have to merge new params (we are parsing individual parameters, we have to add them
 # to the previously parsed general ones)
 name = param_node.getAttribute("name")
-if not checkNode(param_node):
+if not check_node(param_node):
 continue
 if name not in dest_params:
 # this is reached when a previous category exists
 dest_params[name] = param_node.cloneNode(True)
 dest_cat.appendChild(dest_params[name])
-profile_value = self._getParam(
+profile_value = self._get_param(
 category,
 name,
 type_node.nodeName,
 cache=profile_cache,
 profile=profile,
 prof_xml.documentElement.removeChild(node)
 return prof_xml
-def _getParamsUI(self, security_limit, app, extra_s, profile_key):
+def _get_params_ui(self, security_limit, app, extra_s, profile_key):
-client = self.host.getClient(profile_key)
+client = self.host.get_client(profile_key)
 extra = data_format.deserialise(extra_s)
-return defer.ensureDeferred(self.getParamsUI(client, security_limit, app, extra))
+return defer.ensureDeferred(self.param_ui_get(client, security_limit, app, extra))
-async def getParamsUI(self, client, security_limit, app, extra=None):
+async def param_ui_get(self, client, security_limit, app, extra=None):
 """Get XMLUI to handle parameters
 @param security_limit: NO_SECURITY_LIMIT (-1) to return all the params.
 Otherwise sole the params which have a security level defined *and*
 lower or equal to the specified value are returned.
 @param app: name of the frontend requesting the parameters, or '' to get all parameters
 @param extra (dict, None): extra options. Key can be:
 - ignore: list of (category/name) values to remove from parameters
 @return(str): a SàT XMLUI for parameters
 """
-param_xml = await self.getParams(client, security_limit, app, extra)
+param_xml = await self.get_params(client, security_limit, app, extra)
-return paramsXML2XMLUI(param_xml)
+return params_xml_2_xmlui(param_xml)
-async def getParams(self, client, security_limit, app, extra=None):
+async def get_params(self, client, security_limit, app, extra=None):
 """Construct xml for asked profile, take params xml as skeleton
 @param security_limit: NO_SECURITY_LIMIT (-1) to return all the params.
 Otherwise sole the params which have a security level defined *and*
 lower or equal to the specified value are returned.
 @param profile_key: Profile key which can be either a magic (eg: @DEFAULT@) or the name of an existing profile.
 @return: XML of parameters
 """
 if extra is None:
 extra = {}
-prof_xml = await self._constructProfileXml(client, security_limit, app, extra)
+prof_xml = await self._construct_profile_xml(client, security_limit, app, extra)
 return_xml = prof_xml.toxml()
 prof_xml.unlink()
 return "\n".join((line for line in return_xml.split("\n") if line))
-def _getParamNode(self, name, category, type_="@ALL@"):  # FIXME: is type_ useful ?
+def _get_param_node(self, name, category, type_="@ALL@"):  # FIXME: is type_ useful ?
 """Return a node from the param_xml
 @param name: name of the node
 @param category: category of the node
 @param type_: keyword for search:
 @ALL@ search everywhere
 for param in params:
 if param.getAttribute("name") == name:
 return (type_node.nodeName, param)
 return None
-def getParamsCategories(self):
+def params_categories_get(self):
 """return the categories availables"""
 categories = []
 for cat in self.dom.getElementsByTagName("category"):
 name = cat.getAttribute("name")
 if name not in categories:
 categories.append(cat.getAttribute("name"))
 return categories
-def setParam(self, name, value, category, security_limit=C.NO_SECURITY_LIMIT,
+def param_set(self, name, value, category, security_limit=C.NO_SECURITY_LIMIT,
 profile_key=C.PROF_KEY_NONE):
 """Set a parameter, return None if the parameter is not in param xml.
 Parameter of type 'password' that are not the SàT profile password are
 stored encrypted (if not empty). The profile password is stored hashed
 @param category (str): the parameter category
 @param security_limit (int)
 @param profile_key (str): %(doc_profile_key)s
 @return: a deferred None value when everything is done
 """
-# FIXME: setParam should accept the right type for value, not only str !
+# FIXME: param_set should accept the right type for value, not only str !
 if profile_key != C.PROF_KEY_NONE:
-profile = self.getProfileName(profile_key)
+profile = self.get_profile_name(profile_key)
 if not profile:
 log.error(_("Trying to set parameter for an unknown profile"))
 raise exceptions.ProfileUnknownError(profile_key)
-node = self._getParamNode(name, category, "@ALL@")
+node = self._get_param_node(name, category, "@ALL@")
 if not node:
 log.error(
 _("Requesting an unknown parameter (%(category)s/%(name)s)")
 % {"category": category, "name": name}
 )
 return defer.succeed(None)
-if not self.checkSecurityLimit(node[1], security_limit):
+if not self.check_security_limit(node[1], security_limit):
 msg = _(
 "{profile!r} is trying to set parameter {name!r} in category "
 "{category!r} without authorization!!!").format(
 profile=repr(profile),
 name=repr(name),
 }
 )
 if node[0] == C.GENERAL:
 self.params_gen[(category, name)] = value
-self.storage.setGenParam(category, name, value)
+self.storage.set_gen_param(category, name, value)
-for profile in self.storage.getProfilesList():
+for profile in self.storage.get_profiles_list():
-if self.host.memory.isSessionStarted(profile):
+if self.host.memory.is_session_started(profile):
-self.host.bridge.paramUpdate(name, value, category, profile)
+self.host.bridge.param_update(name, value, category, profile)
 self.host.trigger.point(
-"paramUpdateTrigger", name, value, category, node[0], profile
+"param_update_trigger", name, value, category, node[0], profile
 )
 return defer.succeed(None)
 assert node[0] == C.INDIVIDUAL
 assert profile_key != C.PROF_KEY_NONE
 if type_ == "button":
 log.debug("Clicked param button %s" % node.toxml())
 return defer.succeed(None)
 elif type_ == "password":
 try:
-personal_key = self.host.memory.auth_sessions.profileGetUnique(profile)[
+personal_key = self.host.memory.auth_sessions.profile_get_unique(profile)[
 C.MEMORY_CRYPTO_KEY
 ]
 except TypeError:
 raise exceptions.InternalError(
 _("Trying to encrypt a password while the personal key is undefined!")
 )
 if (category, name) == C.PROFILE_PASS_PATH:
 # using 'value' as the encryption key to encrypt another encryption key... could be confusing!
-d = self.host.memory.encryptPersonalData(
+d = self.host.memory.encrypt_personal_data(
 data_key=C.MEMORY_CRYPTO_KEY,
 data_value=personal_key,
 crypto_key=value,
 profile=profile,
 )
 else:
 d = defer.succeed(value)
 else:
 d = defer.succeed(value)
-def gotFinalValue(value):
+def got_final_value(value):
-if self.host.memory.isSessionStarted(profile):
+if self.host.memory.is_session_started(profile):
 self.params[profile][(category, name)] = value
-self.host.bridge.paramUpdate(name, value, category, profile)
+self.host.bridge.param_update(name, value, category, profile)
 self.host.trigger.point(
-"paramUpdateTrigger", name, value, category, node[0], profile
+"param_update_trigger", name, value, category, node[0], profile
 )
-return self.storage.setIndParam(category, name, value, profile)
+return self.storage.set_ind_param(category, name, value, profile)
 else:
 raise exceptions.ProfileNotConnected
-d.addCallback(gotFinalValue)
+d.addCallback(got_final_value)
 return d
-def _getNodesOfTypes(self, attr_type, node_type="@ALL@"):
+def _get_nodes_of_types(self, attr_type, node_type="@ALL@"):
 """Return all the nodes matching the given types.
 TODO: using during the dev but not anymore... remove if not needed
 @param attr_type (str): the attribute type (string, text, password, bool, int, button, list)
 for param in params:
 if param.getAttribute("type") == attr_type:
 ret[(cat, param.getAttribute("name"))] = param
 return ret
-def checkSecurityLimit(self, node, security_limit):
+def check_security_limit(self, node, security_limit):
 """Check the given node against the given security limit.
 The value NO_SECURITY_LIMIT (-1) means that everything is allowed.
 @return: True if this node can be accessed with the given security limit.
 """
 if security_limit < 0:
 if node.hasAttribute("security"):
 if int(node.getAttribute("security")) <= security_limit:
 return True
 return False
-def checkApp(self, node, app):
+def check_app(self, node, app):
 """Check the given node against the given app.
 @param node: parameter node
 @param app: name of the frontend requesting the parameters, or '' to get all parameters
 @return: True if this node concerns the given app.
 """
 if not app or not node.hasAttribute("app"):
 return True
 return node.getAttribute("app") == app
-def checkExtra(self, node, extra):
+def check_extra(self, node, extra):
 """Check the given node against the extra filters.
 @param node: parameter node
 @param app: name of the frontend requesting the parameters, or '' to get all parameters
 @return: True if node doesn't match category/name of extra['ignore'] list
 log.debug(f"Ignoring parameter {category}/{name} as requested")
 return False
 return True
-def makeOptions(options, selected=None):
+def make_options(options, selected=None):
 """Create option XML form dictionary
 @param options(dict): option's name => option's label map
 @param selected(None, str): value of selected option
 None to use first value

Mercurial > libervia-backend

comparison sat/memory/params.py @ 4037:524856bd7b19