--- a/sat/bridge/bridge_constructor/constructors/pb/pb_core_template.py	Fri Apr 07 15:18:39 2023 +0200
+++ b/sat/bridge/bridge_constructor/constructors/pb/pb_core_template.py	Sat Apr 08 13:54:42 2023 +0200
@@ -55,17 +55,17 @@
     def __init__(self):
         self.signals_handlers = []
 
-    def remote_initBridge(self, signals_handler):
+    def remote_init_bridge(self, signals_handler):
         self.signals_handlers.append(HandlerWrapper(signals_handler))
         log.info("registered signal handler")
 
-    def sendSignalEb(self, failure_, signal_name):
+    def send_signal_eb(self, failure_, signal_name):
         if not failure_.check(pb.PBConnectionLost):
             log.error(
                 f"Error while sending signal {signal_name}: {failure_}",
             )
 
-    def sendSignal(self, name, args, kwargs):
+    def send_signal(self, name, args, kwargs):
         to_remove = []
         for wrapper in self.signals_handlers:
             handler = wrapper.handler
@@ -74,13 +74,13 @@
             except pb.DeadReferenceError:
                 to_remove.append(wrapper)
             else:
-                d.addErrback(self.sendSignalEb, name)
+                d.addErrback(self.send_signal_eb, name)
         if to_remove:
             for wrapper in to_remove:
                 log.debug("Removing signal handler for dead frontend")
                 self.signals_handlers.remove(wrapper)
 
-    def _bridgeDeactivateSignals(self):
+    def _bridge_deactivate_signals(self):
         if hasattr(self, "signals_paused"):
             log.warning("bridge signals already deactivated")
             if self.signals_handler:
@@ -90,7 +90,7 @@
         self.signals_handlers = []
         log.debug("bridge signals have been deactivated")
 
-    def _bridgeReactivateSignals(self):
+    def _bridge_reactivate_signals(self):
         try:
             self.signals_handlers = self.signals_paused
         except AttributeError:
@@ -102,31 +102,31 @@
 ##METHODS_PART##
 
 
-class Bridge(object):
+class bridge(object):
     def __init__(self):
         log.info("Init Perspective Broker...")
         self.root = PBRoot()
-        conf = config.parseMainConf()
-        getConf = partial(config.getConf, conf, "bridge_pb", "")
-        conn_type = getConf("connection_type", "unix_socket")
+        conf = config.parse_main_conf()
+        get_conf = partial(config.get_conf, conf, "bridge_pb", "")
+        conn_type = get_conf("connection_type", "unix_socket")
         if conn_type == "unix_socket":
-            local_dir = Path(config.getConfig(conf, "", "local_dir")).resolve()
+            local_dir = Path(config.config_get(conf, "", "local_dir")).resolve()
             socket_path = local_dir / "bridge_pb"
             log.info(f"using UNIX Socket at {socket_path}")
             reactor.listenUNIX(
                 str(socket_path), pb.PBServerFactory(self.root), mode=0o600
             )
         elif conn_type == "socket":
-            port = int(getConf("port", 8789))
+            port = int(get_conf("port", 8789))
             log.info(f"using TCP Socket at port {port}")
             reactor.listenTCP(port, pb.PBServerFactory(self.root))
         else:
             raise ValueError(f"Unknown pb connection type: {conn_type!r}")
 
-    def sendSignal(self, name, *args, **kwargs):
-        self.root.sendSignal(name, args, kwargs)
+    def send_signal(self, name, *args, **kwargs):
+        self.root.send_signal(name, args, kwargs)
 
-    def remote_initBridge(self, signals_handler):
+    def remote_init_bridge(self, signals_handler):
         self.signals_handlers.append(signals_handler)
         log.info("registered signal handler")
 
@@ -135,32 +135,32 @@
         setattr(self.root, "remote_" + name, callback)
         #  self.root.register_method(name, callback)
 
-    def addMethod(
+    def add_method(
             self, name, int_suffix, in_sign, out_sign, method, async_=False, doc={}
     ):
-        """Dynamically add a method to PB Bridge"""
+        """Dynamically add a method to PB bridge"""
         # FIXME: doc parameter is kept only temporary, the time to remove it from calls
         log.debug("Adding method {name} to PB bridge".format(name=name))
         self.register_method(name, method)
 
-    def addSignal(self, name, int_suffix, signature, doc={}):
+    def add_signal(self, name, int_suffix, signature, doc={}):
         log.debug("Adding signal {name} to PB bridge".format(name=name))
         setattr(
-            self, name, lambda *args, **kwargs: self.sendSignal(name, *args, **kwargs)
+            self, name, lambda *args, **kwargs: self.send_signal(name, *args, **kwargs)
         )
 
-    def bridgeDeactivateSignals(self):
+    def bridge_deactivate_signals(self):
         """Stop sending signals to bridge
 
         Mainly used for mobile frontends, when the frontend is paused
         """
-        self.root._bridgeDeactivateSignals()
+        self.root._bridge_deactivate_signals()
 
-    def bridgeReactivateSignals(self):
+    def bridge_reactivate_signals(self):
         """Send again signals to bridge
 
-        Should only be used after bridgeDeactivateSignals has been called
+        Should only be used after bridge_deactivate_signals has been called
         """
-        self.root._bridgeReactivateSignals()
+        self.root._bridge_reactivate_signals()
 
 ##SIGNALS_PART##