linting and CI fixes

Author: dr7ana

sogs/model/clientmanager.py

@@ -79,26 +79,20 @@ class ClientManager:
         queue - BotQueue object
     """
 
-    def __init__(
-        self,
-        *,
-        id: Optional[int] = None,
-    ) -> None:
+    def __init__(self, *, id: Optional[int] = None) -> None:
         self.id = id
         self.filter = False
         self.bqueue = BotQueue()
         self.clients = []
 
-
     def bqempty(self):
         return not self.bqueue._empty()
-    
 
     def register_client(self, conn_id, cid, authlevel, bot, priority):
         if not bot:
             # add client to self.clients
             return
-        
+
         if not priority:
             # if no priority is given, lowest priority is assigned
             priority = self.qsize()
@@ -108,19 +102,16 @@ def register_client(self, conn_id, cid, authlevel, bot, priority):
                 priority += 1
         self.bqueue._put(PriorityTuple(priority, bot))
 
-
     def deregister_client(self, cid, bot):
         if not bot:
             # remove client from clients list
             return
-        
+
         # remove bot from bot queue
-        
 
     def peek(self, priority: int):
         return self.bqueue._peek(priority)
 
-
     def check_permission_for(
         self,
         room: Room,

sogs/model/room.py

@@ -154,7 +154,6 @@ def _refresh(self, *, id=None, token=None, row=None, perms=False):
         if perms or not hasattr(self, '_perm_cache'):
             self._perm_cache = {}
 
-
     def __str__(self):
         """Returns `Room[token]` when converted to a str"""
         return f"Room[{self.token}]"

sogs/mule.py

@@ -111,7 +111,6 @@ def setup_omq(self, omq: OMQ):
         omq.mule_conn = omq.connect_inproc(on_success=None, on_failure=self.inproc_fail)
 
 
-
 """
 TOFIX: oxenmq calls should pass as oxenmq.Message not as JSON
 

sogs/omq.py

@@ -4,8 +4,8 @@
 import oxenmq, queue
 from oxenc import bt_serialize, bt_deserialize
 
-from mule import log_exceptions
-from routes import omq_auth
+from .mule import log_exceptions
+from .routes import omq_auth
 from . import crypto, config
 from .postfork import postfork
 from .model.clientmanager import ClientManager
@@ -36,7 +36,7 @@ def __init__(self):
         if uwsgi.mule_id() != 0:
             uwsgi.opt['mule'].setup_omq(self)
             return
-        
+
         uwsgi.register_signal(123, 'internal', self.handle_proxied_omq_req)
 
         from .web import app  # Imported here to avoid circular import
@@ -52,57 +52,49 @@ def __init__(self):
         global omq_global
         omq_global = self
 
-    
     @log_exceptions
     def subreq_response(self):
         pass
 
-
     @log_exceptions
     def handle_proxied_omq_req(self):
-        id, subreq_body = self.send_mule(
-            command='get_next_request',
-            prefix='internal'
-        )
+        id, subreq_body = self.send_mule(command='get_next_request', prefix='internal')
 
         '''
             
             Handle omq subrequest
 
         '''
 
-        return 
+        return
 
     @log_exceptions
     def get_next_request(self):
         subreq_body = self.subreq_queue.get()
         id = list(subreq_body.keys())[0]
         return id, subreq_body[id]
 
-
     @log_exceptions
     def register_client(self, msg: oxenmq.Message):
         cid, authlevel, bot, priority = bt_deserialize(msg.data()[0])
         conn_id = msg.conn()
         self.client_map[conn_id] = cid
         self.manager.register_client(msg)
 
-
     @log_exceptions
     def deregister_client(self, msg: oxenmq.Message):
         cid, bot = bt_deserialize(msg.data()[0])
         self.client_map.pop(cid)
         self.manager.deregister_client(cid, bot)
 
-
     def send_mule(self, command, *args, prefix="worker."):
         """
         Sends a command to the mule from a worker (or possibly from the mule itself).  The command will
         be prefixed with "worker." (unless overridden).
 
         Any args will be bt-serialized and send as message parts.
         """
-        
+
         if prefix:
             command = prefix + command
 

sogs/routes/clients.py

@@ -22,7 +22,7 @@
 @omq_auth.first_request
 def register(cid):
     """
-    Registers a client with SOGS OMQ instance. In this context, "client" refers to any entity 
+    Registers a client with SOGS OMQ instance. In this context, "client" refers to any entity
     seeking to create an authenticated OMQ connection. This may be, but is not limited to,
     a user or a bot
 
@@ -44,12 +44,11 @@ def register(cid):
     """
 
     req = request.json
-    bot = utils.get_int_param('bot')    # will set bot == 1 if key "bot" has value True
+    bot = utils.get_int_param('bot')  # will set bot == 1 if key "bot" has value True
     authlevel = req.get('authlevel')
     priority = req.get('priority')
-    
-    client = (bot is 1)[register_client(cid, authlevel),
-                        register_bot(cid, authlevel, priority)]
+
+    client = (bot is 1)[register_client(cid, authlevel), register_bot(cid, authlevel, priority)]
 
     return client
 
@@ -78,7 +77,7 @@ def register_bot(cid, authlevel, priority):
         authlevel=authlevel,
         bot=1,
         priority=priority,
-        prefix='handler'
+        prefix='handler',
     )
 
     return client
@@ -106,7 +105,7 @@ def register_client(cid, authlevel):
         authlevel=authlevel,
         bot=0,
         priority=None,
-        prefix='handler'
+        prefix='handler',
     )
 
     return client
@@ -125,7 +124,7 @@ def unregister(cid):
 
         - 'bot' (bool) : is bot or not
     """
-    
+
     bot = utils.get_int_param('bot')
 
     client = (bot)[unregister_client(cid), unregister_bot(cid)]
@@ -137,25 +136,15 @@ def unregister(cid):
 @clients.delete("/client/registered/client/<cid>")
 def unregister_client(cid):
 
-    client = omq_global.send_mule(
-        command='unregister_client',
-        cid=cid,
-        bot=0,
-        prefix='handler'
-    )
-    
+    client = omq_global.send_mule(command='unregister_client', cid=cid, bot=0, prefix='handler')
+
     return client
 
 
 @clients.post("/bot/deregistered/bot/<cid>")
 @clients.delete("/bot/registered/bot/<cid>")
 def unregister_bot(cid):
-    
-    client = omq_global.send_mule(
-        command='unregister_bot',
-        cid=cid,
-        bot=1,
-        prefix='handler'
-    )
+
+    client = omq_global.send_mule(command='unregister_bot', cid=cid, bot=1, prefix='handler')
 
     return client

sogs/routes/messages.py

@@ -10,6 +10,7 @@
 messages = Blueprint('messages', __name__)
 blueprints_global['messages'] = messages
 
+
 def qs_reactors():
     return utils.get_int_param('reactors', 4, min=0, max=20, truncate=True)
 
@@ -314,6 +315,7 @@ def message_single(room: Room, msg_id):
         - add some decorator to this s.t. it routes it to the correct OMQ endpoint
 """
 
+
 @messages.post("/room/<Room:room>/message")
 @auth.user_required
 def post_message(room: Room):

sogs/routes/omq_auth.py

@@ -20,14 +20,15 @@
 
 omq = Blueprint('endpoint', __name__)
 
+
 def endpoint(f):
-    """ 
+    """
     Default endpoint for omq routes to pass requests to; constructs flask HTTP request
 
     Message (request) components:
 
     "blueprint" - the flask blueprint
-    "query" - the request query 
+    "query" - the request query
     "pubkey" - pk of client making request
     "params" - a json value to dump as the the query parameters
 
@@ -52,64 +53,68 @@ def abort_request(code, msg, warn=True):
 
 
 def require_client():
-    """ 
-    Requires that an authenticated client was found in the OMQ instance; aborts with 
-    UNAUTHORIZED if the request has no client 
+    """
+    Requires that an authenticated client was found in the OMQ instance; aborts with
+    UNAUTHORIZED if the request has no client
     """
     if g.client_id is None:
         abort_request(http.UNAUTHORIZED, 'OMQ client authentication required')
 
 
 def client_required(f):
-    """ 
-    Decorator for an endpoint that requires a client; this calls require_client() at the 
-    beginning of the request to abort the request as UNAUTHORIZED if the client has not been 
-    previously authenticated 
+    """
+    Decorator for an endpoint that requires a client; this calls require_client() at the
+    beginning of the request to abort the request as UNAUTHORIZED if the client has not been
+    previously authenticated
     """
 
     @wraps(f)
     def required_client_wrapper(*args, **kwargs):
         require_client()
         return f(*args, **kwargs)
-    
+
     return required_client_wrapper
 
 
 def require_authlevel(admin=True):
     require_client()
-    if g.client_authlevel is not oxenmq.Authlevel.admin if admin else g.client_authlevel is not oxenmq.Authlevel.basic:
+    if (
+        g.client_authlevel is not oxenmq.Authlevel.admin
+        if admin
+        else g.client_authlevel is not oxenmq.Authlevel.basic
+    ):
         abort_request(
-            http.FORBIDDEN, 
-            f"This endpoint requires oxenmq.Authlevel.{'admin' if admin else 'basic'} permissions"
+            http.FORBIDDEN,
+            f"This endpoint requires oxenmq.Authlevel.{'admin' if admin else 'basic'} permissions",
         )
 
 
 def basic_required(f):
-    """ Decorator for an endpoint that requires a client has basic OMQ authorization """
+    """Decorator for an endpoint that requires a client has basic OMQ authorization"""
 
     @wraps(f)
     def required_basic_wrapper(*args, **kwargs):
         require_authlevel(admin=False)
         return f(*args, **kwargs)
-    
+
     return required_basic_wrapper
 
 
 def admin_required(f):
-    """ Decorator for an endpoint that requires a client has admin OMQ authorization """
+    """Decorator for an endpoint that requires a client has admin OMQ authorization"""
 
     @wraps(f)
     def required_admin_wrapper(*args, **kwargs):
         require_authlevel(admin=True)
         return f(*args, **kwargs)
-    
+
     return required_admin_wrapper
 
 
 def first_request(f):
-    """ Decorator for an endpoint that will be the very first request for a given client. This 
+    """Decorator for an endpoint that will be the very first request for a given client. This
     will ensure that the client is then registered for any subsequent requests.
-    
+
     This function will typically take the folling parameters:
         - cid : unique client ID to be attributed
         - authlevel (oxenmq)
@@ -119,7 +124,7 @@ def first_request(f):
     def first_request_wrapper(*args, cid, authlevel, **kwargs):
         handle_omq_registration(cid, authlevel)
         return f(*args, cid=cid, authlevel=authlevel, **kwargs)
-    
+
     return first_request_wrapper
 
 
@@ -128,9 +133,11 @@ def handle_omq_registration(sid, authlevel):
     Registers client with OMQ instance before its very first request
     """
     if hasattr(g, 'client_id') and hasattr(g, 'client_authlevel') and not g.client_reauth:
-        app.logger.warning(f"Client {g.client_id} already registered for {g.client_authlevel} access")
+        app.logger.warning(
+            f"Client {g.client_id} already registered for {g.client_authlevel} access"
+        )
         return
-    
+
     """
     Here goes ye olde OMQ registration logic. We need to decide what identification will
     be used to verify every connected client s.t. that information persists for all subsequent
@@ -147,11 +154,13 @@ def verify_omq_auth():
     """
     Verifies OMQ authentication before each request
     """
-    
+
     # If there is already a g.o_id, then this is NOT the first request made by this client, unless
     # g.client_reauth has been specifically set
     if hasattr(g, 'client_id') and hasattr(g, 'client_authlevel') and not g.client_reauth:
-        app.logger.debug(f"Client {g.client_id} already authenticated for {g.client_authlevel} access")
+        app.logger.debug(
+            f"Client {g.client_id} already authenticated for {g.client_authlevel} access"
+        )
         return