refactoring to camel_case, some fixes

server/src/uds/REST/methods/users_groups.py

@@ -142,7 +142,7 @@ class Users(DetailHandler):
                 res['staff_member'] and (res['is_admin'] and _('Admin') or _('Staff member')) or _('User')
             )
             usr = aUser(u)
-            res['groups'] = [g.dbGroup().uuid for g in usr.groups()]
+            res['groups'] = [g.db_group().uuid for g in usr.groups()]
             logger.debug('Item: %s', res)
             return res
         except Exception as e:
@@ -230,7 +230,7 @@ class Users(DetailHandler):
                     )  # this throws an exception if there is an error (for example, this auth can't create users)
                     user = parent.users.create(**fields)
                 else:
-                    auth.modift_user(fields)  # Notifies authenticator
+                    auth.modify_user(fields)  # Notifies authenticator
                     user = parent.users.get(uuid=processUuid(item))
                     user.__dict__.update(fields)
                     user.save()

server/src/uds/auths/RegexLdap/authenticator.py

@@ -542,7 +542,7 @@ class RegexLdap(auths.Authenticator):
             return username
         return self.__getUserRealName(res)
 
-    def modift_user(self, usrData: dict[str, str]) -> None:
+    def modify_user(self, usrData: dict[str, str]) -> None:
         """
         We must override this method in authenticators not based on external sources (i.e. database users, text file users, etc..)
         Modify user has no reason on external sources, so it will never be used (probably)

server/src/uds/auths/Sample/SampleAuth.py

@@ -314,7 +314,7 @@ class SampleAuth(auths.Authenticator):
         usrData['real_name'] = usrData['name'] + ' ' + usrData['name']
         usrData['state'] = State.INACTIVE
 
-    def modift_user(self, usrData: dict[str, str]) -> None:
+    def modify_user(self, usrData: dict[str, str]) -> None:
         """
         This method provides a "check opportunity" to authenticator for users modified
         at administration interface.

server/src/uds/auths/SimpleLDAP/authenticator.py

@@ -492,7 +492,7 @@ class SimpleLDAPAuthenticator(auths.Authenticator):
             return username
         return self.__getUserRealName(res)
 
-    def modift_user(self, usrData: dict[str, str]) -> None:
+    def modify_user(self, usrData: dict[str, str]) -> None:
         '''
         We must override this method in authenticators not based on external sources (i.e. database users, text file users, etc..)
         Modify user has no reason on external sources, so it will never be used (probably)

server/src/uds/core/auths/authenticator.py

@@ -228,7 +228,7 @@ class Authenticator(Module):
             groupsManager = GroupsManager(self.db_obj())
             self.get_groups(user.name, groupsManager)
             # cast for typechecking. user.groups is a "simmmilar to a QuerySet", but it's not a QuerySet, so "set" is not there
-            typing.cast(typing.Any, user.groups).set([g.dbGroup() for g in groupsManager.getValidGroups()])
+            typing.cast(typing.Any, user.groups).set([g.db_group() for g in groupsManager.getValidGroups()])
 
     def callback_url(self) -> str:
         """
@@ -622,7 +622,7 @@ class Authenticator(Module):
 
         """
 
-    def modift_user(self, usrData: dict[str, str]) -> None:
+    def modify_user(self, usrData: dict[str, str]) -> None:
         """
         This method is used when modifying an user to allow the authenticator:
 

server/src/uds/core/auths/group.py

@@ -50,13 +50,14 @@ class Group:
 
     It's only constructor expect a database group as parameter.
     """
+    _db_group: 'DBGroup'
 
-    def __init__(self, dbGroup: 'DBGroup'):
+    def __init__(self, db_group: 'DBGroup'):
         """
         Initializes internal data
         """
-        self._manager = dbGroup.getManager()
+        self._manager = db_group.getManager()
-        self._dbGroup = dbGroup
+        self._db_group = db_group
 
     def manager(self) -> 'AuthenticatorInstance':
         """
@@ -64,8 +65,8 @@ class Group:
         """
         return self._manager
 
-    def dbGroup(self) -> 'DBGroup':
+    def db_group(self) -> 'DBGroup':
         """
         Returns the database group associated with this
         """
-        return self._dbGroup
+        return self._db_group

server/src/uds/core/auths/groups_manager.py

@@ -131,7 +131,7 @@ class GroupsManager:
         as where inserted inside Database (most probably using administration interface)
         """
         for g in self._groups:
-            yield g.group.dbGroup().name
+            yield g.group.db_group().name
 
     def getValidGroups(self) -> typing.Generator['Group', None, None]:
         """
@@ -143,7 +143,7 @@ class GroupsManager:
         valid_id_list: list[int] = []
         for group in self._groups:
             if group.is_valid:
-                valid_id_list.append(group.group.dbGroup().id)
+                valid_id_list.append(group.group.db_group().id)
                 yield group.group
 
         # Now, get metagroups and also return them

server/src/uds/core/auths/user.py

@@ -54,25 +54,25 @@ class User:
     """
 
     _manager: 'AuthenticatorInstance'
-    _grpsManager: typing.Optional['GroupsManager']
+    grps_manager: typing.Optional['GroupsManager']
-    _dbUser: 'DBUser'
+    _db_user: 'DBUser'
     _groups: typing.Optional[list[Group]]
 
-    def __init__(self, dbUser):
+    def __init__(self, db_user: 'DBUser') -> None:
-        self._manager = dbUser.getManager()
+        self._manager = db_user.getManager()
-        self._grpsManager = None
+        self.grps_manager = None
-        self._dbUser = dbUser
+        self._db_user = db_user
         self._groups = None
 
-    def _groupsManager(self) -> 'GroupsManager':
+    def _groups_manager(self) -> 'GroupsManager':
         """
         If the groups manager for this user already exists, it returns this.
         If it does not exists, it creates one default from authenticator and
         returns it.
         """
-        if self._grpsManager is None:
+        if self.grps_manager is None:
-            self._grpsManager = GroupsManager(self._manager.db_obj())
+            self.grps_manager = GroupsManager(self._manager.db_obj())
-        return self._grpsManager
+        return self.grps_manager
 
     def groups(self) -> list[Group]:
         """
@@ -88,15 +88,15 @@ class User:
 
         if self._groups is None:
             if self._manager.isExternalSource:
-                self._manager.get_groups(self._dbUser.name, self._groupsManager())
+                self._manager.get_groups(self._db_user.name, self._groups_manager())
-                self._groups = list(self._groupsManager().getValidGroups())
+                self._groups = list(self._groups_manager().getValidGroups())
                 logger.debug(self._groups)
                 # This is just for updating "cached" data of this user, we only get real groups at login and at modify user operation
-                usr = DBUser.objects.get(pk=self._dbUser.id)  # @UndefinedVariable
+                usr = DBUser.objects.get(pk=self._db_user.id)  # @UndefinedVariable
-                usr.groups.set((g.dbGroup().id for g in self._groups if g.dbGroup().is_meta is False))  # type: ignore
+                usr.groups.set((g.db_group().id for g in self._groups if g.db_group().is_meta is False))  # type: ignore
             else:
                 # From db
-                usr = DBUser.objects.get(pk=self._dbUser.id)  # @UndefinedVariable
+                usr = DBUser.objects.get(pk=self._db_user.id)  # @UndefinedVariable
                 self._groups = [Group(g) for g in usr.getGroups()]
         return self._groups
 
@@ -106,8 +106,8 @@ class User:
         """
         return self._manager
 
-    def dbUser(self) -> 'DBUser':
+    def db_user(self) -> 'DBUser':
         """
         Returns the database user
         """
-        return self._dbUser
+        return self._db_user

server/src/uds/core/consts/os.py

@@ -53,9 +53,9 @@ MOBILE_OS_LIST: typing.Final[tuple[types.os.KnownOS, ...]] = tuple(set(ALL_OS_LI
 DEFAULT_OS: typing.Final[types.os.KnownOS] = types.os.KnownOS.WINDOWS
 
 
-knownBrowsers: typing.Final[tuple[types.os.KnownBrowser, ...]] = tuple(types.os.KnownBrowser)
+known_browsers: typing.Final[tuple[types.os.KnownBrowser, ...]] = tuple(types.os.KnownBrowser)
 
-browsersREs: dict[types.os.KnownBrowser, tuple] = {
+browsers_re: dict[types.os.KnownBrowser, tuple] = {
     types.os.KnownBrowser.FIREFOX: (re.compile(r'Firefox/([0-9.]+)'),),
     types.os.KnownBrowser.SEAMONKEY: (re.compile(r'Seamonkey/([0-9.]+)'),),
     types.os.KnownBrowser.CHROME: (re.compile(r'Chrome/([0-9.]+)'),),
@@ -72,7 +72,7 @@ browsersREs: dict[types.os.KnownBrowser, tuple] = {
     types.os.KnownBrowser.EDGE: (re.compile(r'Edg/([0-9.]+)'),),
 }
 
-browserRules: dict[types.os.KnownBrowser, tuple] = {
+browser_rules: dict[types.os.KnownBrowser, tuple] = {
     types.os.KnownBrowser.EDGE: (types.os.KnownBrowser.EDGE, ()),
     types.os.KnownBrowser.CHROME: (
         types.os.KnownBrowser.CHROME,

server/src/uds/core/jobs/delayed_task.py

@@ -74,7 +74,7 @@ class DelayedTask(Environmentable):
         """
         from .delayed_task_runner import DelayedTaskRunner  # pylint: disable=import-outside-toplevel
 
-        if check and DelayedTaskRunner.runner().checkExists(tag):
+        if check and DelayedTaskRunner.runner().tag_exists(tag):
             return
 
         DelayedTaskRunner.runner().insert(self, suggestedTime, tag)

server/src/uds/core/jobs/delayed_task_runner.py

@@ -57,17 +57,17 @@ class DelayedTaskThread(threading.Thread):
     Class responsible of executing a delayed task in its own thread
     """
 
-    __slots__ = ('_taskInstance',)
+    __slots__ = ('_task_instance',)
 
-    _taskInstance: DelayedTask
+    _task_instance: DelayedTask
 
-    def __init__(self, taskInstance: DelayedTask) -> None:
+    def __init__(self, task_instance: DelayedTask) -> None:
         super().__init__()
-        self._taskInstance = taskInstance
+        self._task_instance = task_instance
 
     def run(self) -> None:
         try:
-            self._taskInstance.execute()
+            self._task_instance.execute()
         except Exception as e:
             logger.exception("Exception in thread %s: %s", e.__class__, e)
         finally:
@@ -83,11 +83,11 @@ class DelayedTaskRunner(metaclass=singleton.Singleton):
 
     granularity: typing.ClassVar[int] = 2  # we check for delayed tasks every "granularity" seconds
     _hostname: typing.ClassVar[str]  # "Our" hostname
-    _keepRunning: typing.ClassVar[bool]  # If we should keep it running
+    _keep_running: typing.ClassVar[bool]  # If we should keep it running
 
     def __init__(self):
         DelayedTaskRunner._hostname = gethostname()
-        DelayedTaskRunner._keepRunning = True
+        DelayedTaskRunner._keep_running = True
         logger.debug("Initialized delayed task runner for host %s", DelayedTaskRunner._hostname)
 
     def notifyTermination(self) -> None:
@@ -95,7 +95,7 @@ class DelayedTaskRunner(metaclass=singleton.Singleton):
         Invoke this whenever you want to terminate the delayed task runner thread
         It will mark the thread to "stop" ASAP
         """
-        DelayedTaskRunner._keepRunning = False
+        DelayedTaskRunner._keep_running = False
 
     @staticmethod
     def runner() -> 'DelayedTaskRunner':
@@ -106,7 +106,7 @@ class DelayedTaskRunner(metaclass=singleton.Singleton):
         """
         return DelayedTaskRunner()
 
-    def executeOneDelayedTask(self) -> None:
+    def execute_delayed_task(self) -> None:
         now = getSqlDatetime()
         filt = Q(execution_time__lt=now) | Q(insert_date__gt=now + timedelta(seconds=30))
         # If next execution is before now or last execution is in the future (clock changed on this server, we take that task as executable)
@@ -196,7 +196,7 @@ class DelayedTaskRunner(metaclass=singleton.Singleton):
         except Exception as e:
             logger.exception('Exception removing a delayed task %s: %s', e.__class__, e)
 
-    def checkExists(self, tag: str) -> bool:
+    def tag_exists(self, tag: str) -> bool:
         if not tag:
             return False
 
@@ -210,10 +210,10 @@ class DelayedTaskRunner(metaclass=singleton.Singleton):
 
     def run(self) -> None:
         logger.debug("At loop")
-        while DelayedTaskRunner._keepRunning:
+        while DelayedTaskRunner._keep_running:
             try:
                 time.sleep(self.granularity)
-                self.executeOneDelayedTask()
+                self.execute_delayed_task()
             except Exception as e:
                 logger.error('Unexpected exception at run loop %s: %s', e.__class__, e)
                 try:

server/src/uds/core/jobs/scheduler.py

@@ -121,10 +121,12 @@ class Scheduler:
 
     # to keep singleton Scheduler
     _scheduler: typing.Optional['Scheduler'] = None
+    _hostname: str
+    _keep_running: bool
 
     def __init__(self) -> None:
         self._hostname = platform.node()
-        self._keepRunning = True
+        self._keep_running = True
         logger.info('Initialized scheduler for host "%s"', self._hostname)
 
     @staticmethod
@@ -136,13 +138,13 @@ class Scheduler:
             Scheduler._scheduler = Scheduler()
         return Scheduler._scheduler
 
-    def notifyTermination(self) -> None:
+    def notify_termination(self) -> None:
         """
         Invoked to signal that termination of scheduler task(s) is requested
         """
-        self._keepRunning = False
+        self._keep_running = False
 
-    def executeOneJob(self) -> None:
+    def execute_job(self) -> None:
         """
         Looks for the best waiting job and executes it
         """
@@ -192,7 +194,7 @@ class Scheduler:
             ) from e
 
     @staticmethod
-    def releaseOwnShedules() -> None:
+    def release_own_shedules() -> None:
         """
         Releases all scheduleds being executed by this server
         """
@@ -222,10 +224,10 @@ class Scheduler:
         logger.debug('Run Scheduler thread')
         JobsFactory().ensureJobsInDatabase()
         logger.debug("At loop")
-        while self._keepRunning:
+        while self._keep_running:
             try:
                 time.sleep(self.granularity)
-                self.executeOneJob()
+                self.execute_job()
             except Exception as e:
                 # This can happen often on sqlite, and this is not problem at all as we recover it.
                 # The log is removed so we do not get increased workers.log file size with no information at all
@@ -238,4 +240,4 @@ class Scheduler:
                 except Exception:
                     logger.exception('Exception clossing connection at delayed task')
         logger.info('Exiting Scheduler because stop has been requested')
-        self.releaseOwnShedules()
+        self.release_own_shedules()

server/src/uds/core/managers/task.py

@@ -55,7 +55,7 @@ class SchedulerThread(BaseThread):
         Scheduler.scheduler().run()
 
     def notifyTermination(self):
-        Scheduler.scheduler().notifyTermination()
+        Scheduler.scheduler().notify_termination()
 
 
 class DelayedTaskThread(BaseThread):
@@ -120,7 +120,7 @@ class TaskManager(metaclass=singleton.Singleton):
         connection.close()
 
         # Releases owned schedules so anyone can access them...
-        Scheduler.releaseOwnShedules()
+        Scheduler.release_own_shedules()
 
         self.registerScheduledTasks()
 

server/src/uds/core/managers/userservice/opchecker.py

@@ -261,7 +261,7 @@ class UserServiceOpChecker(DelayedTask):
         @param pi: Instance of Publication manager for the object
         """
         # Do not add task if already exists one that updates this service
-        if DelayedTaskRunner.runner().checkExists(USERSERVICE_TAG + userService.uuid):
+        if DelayedTaskRunner.runner().tag_exists(USERSERVICE_TAG + userService.uuid):
             return
         DelayedTaskRunner.runner().insert(
             UserServiceOpChecker(userService),

server/src/uds/core/util/os_detector.py

@@ -79,7 +79,7 @@ def detect_os(
     # Try to detect browser from Sec-Ch-Ua first
     secChUa = headers.get('Sec-Ch-Ua')
     if secChUa is not None:
-        for browser in consts.os.knownBrowsers:
+        for browser in consts.os.known_browsers:
             if browser in secChUa:
                 res.browser = browser
                 break
@@ -88,16 +88,16 @@ def detect_os(
         match = None
 
         ruleKey, ruleValue = None, None
-        for ruleKey, ruleValue in consts.os.browserRules.items():
+        for ruleKey, ruleValue in consts.os.browser_rules.items():
             must, mustNot = ruleValue
 
-            for mustRe in consts.os.browsersREs[must]:
+            for mustRe in consts.os.browsers_re[must]:
                 match = mustRe.search(ua)
                 if match is None:
                     continue
                 # Check against no maching rules
                 for mustNotREs in mustNot:
-                    for cre in consts.os.browsersREs[mustNotREs]:
+                    for cre in consts.os.browsers_re[mustNotREs]:
                         if cre.search(ua) is not None:
                             match = None
                             break