Formatting.

src/snek/app.py

@@ -1,5 +1,4 @@
 import pathlib
-from types import SimpleNamespace
 
 from aiohttp import web
 from aiohttp_session import (
@@ -21,10 +20,8 @@ from snek.view.about import AboutHTMLView, AboutMDView
 from snek.view.docs import DocsHTMLView, DocsMDView
 from snek.view.index import IndexView
 from snek.view.login import LoginView
-from snek.view.login_form import LoginFormView
 from snek.view.logout import LogoutView
 from snek.view.register import RegisterView
-from snek.view.register_form import RegisterFormView
 from snek.view.status import StatusView
 from snek.view.web import WebView
 

src/snek/mapper/__init__.py

@@ -1,5 +1,4 @@
 import functools
-from types import SimpleNamespace
 
 from snek.mapper.channel import ChannelMapper
 from snek.mapper.channel_member import ChannelMemberMapper
@@ -11,11 +10,13 @@ from snek.system.object import Object
 @functools.cache
 def get_mappers(app=None):
     return Object(
-        **{"user": UserMapper(app=app),
+        **{
-            'channel_member': ChannelMemberMapper(app=app),
+            "user": UserMapper(app=app),
-            'channel': ChannelMapper(app=app),
+            "channel_member": ChannelMemberMapper(app=app),
-            'channel_message': ChannelMessageMapper(app=app)    
+            "channel": ChannelMapper(app=app),
-    })
+            "channel_message": ChannelMessageMapper(app=app),
+        }
+    )
 
 
 def get_mapper(name, app=None):

src/snek/mapper/channel_message.py

@@ -4,4 +4,4 @@ from snek.system.mapper import BaseMapper
 
 class ChannelMessageMapper(BaseMapper):
     model_class = ChannelMessageModel
-    table_name = "channel_message"
+    table_name = "channel_message"

src/snek/model/__init__.py

@@ -2,7 +2,8 @@ import functools
 
 from snek.model.channel import ChannelModel
 from snek.model.channel_member import ChannelMemberModel
-#from snek.model.channel_message import ChannelMessageModel
+
+# from snek.model.channel_message import ChannelMessageModel
 from snek.model.channel_message import ChannelMessageModel
 from snek.model.user import UserModel
 from snek.system.object import Object
@@ -10,10 +11,14 @@ from snek.system.object import Object
 
 @functools.cache
 def get_models():
-    return Object(**{"user": UserModel,
+    return Object(
+        **{
+            "user": UserModel,
             "channel_member": ChannelMemberModel,
             "channel": ChannelModel,
-            "channel_message": ChannelMessageModel})
+            "channel_message": ChannelMessageModel,
+        }
+    )
 
 
 def get_model(name):

src/snek/model/channel.py

@@ -1,11 +1,11 @@
 from snek.system.model import BaseModel, ModelField
 
-class ChannelModel(BaseModel):
-    label = ModelField(name="label", required=True,kind=str)
-    description = ModelField(name="description", required=False,kind=str)
-    tag = ModelField(name="tag", required=False,kind=str)
-    created_by_uid = ModelField(name="created_by_uid", required=True,kind=str)
-    is_private = ModelField(name="is_private", required=True,kind=bool,value=False)
-    is_listed = ModelField(name="is_listed", required=True,kind=bool,value=True)
-    index = ModelField(name="index", required=True,kind=int,value=1000) 
 
+class ChannelModel(BaseModel):
+    label = ModelField(name="label", required=True, kind=str)
+    description = ModelField(name="description", required=False, kind=str)
+    tag = ModelField(name="tag", required=False, kind=str)
+    created_by_uid = ModelField(name="created_by_uid", required=True, kind=str)
+    is_private = ModelField(name="is_private", required=True, kind=bool, value=False)
+    is_listed = ModelField(name="is_listed", required=True, kind=bool, value=True)
+    index = ModelField(name="index", required=True, kind=int, value=1000)

src/snek/model/channel_member.py

@@ -1,10 +1,15 @@
 from snek.system.model import BaseModel, ModelField
 
+
 class ChannelMemberModel(BaseModel):
-    label = ModelField(name="label", required=True,kind=str)
+    label = ModelField(name="label", required=True, kind=str)
-    channel_uid = ModelField(name="channel_uid", required=True,kind=str)
+    channel_uid = ModelField(name="channel_uid", required=True, kind=str)
-    user_uid = ModelField(name="user_uid", required=True,kind=str)
+    user_uid = ModelField(name="user_uid", required=True, kind=str)
-    is_moderator = ModelField(name="is_moderator", required=True,kind=bool,value=False)
+    is_moderator = ModelField(
-    is_read_only = ModelField(name="is_read_only", required=True,kind=bool,value=False)
+        name="is_moderator", required=True, kind=bool, value=False
-    is_muted = ModelField(name="is_muted", required=True,kind=bool,value=False)
+    )
-    is_banned = ModelField(name="is_banned", required=True,kind=bool,value=False)
+    is_read_only = ModelField(
+        name="is_read_only", required=True, kind=bool, value=False
+    )
+    is_muted = ModelField(name="is_muted", required=True, kind=bool, value=False)
+    is_banned = ModelField(name="is_banned", required=True, kind=bool, value=False)

src/snek/model/channel_message.py

@@ -1,9 +1,7 @@
-
-
 from snek.system.model import BaseModel, ModelField
 
 
 class ChannelMessageModel(BaseModel):
-    channel_uid = ModelField(name="channel_uid", required=True,kind=str)
+    channel_uid = ModelField(name="channel_uid", required=True, kind=str)
-    user_uid = ModelField(name="user_uid", required=True,kind=str)
+    user_uid = ModelField(name="user_uid", required=True, kind=str)
-    message = ModelField(name="message", required=True,kind=str)
+    message = ModelField(name="message", required=True, kind=str)

src/snek/model/notification.py

@@ -1,6 +1,3 @@
-
-
-
 from snek.system.model import BaseModel, ModelField
 
 
@@ -9,4 +6,4 @@ class NotificationModel(BaseModel):
     object_type = ModelField(name="object_type", required=True)
     message = ModelField(name="message", required=True)
     user_uid = ModelField(name="user_uid", required=True)
-    read_at = ModelField(name="is_read", required=True)
+    read_at = ModelField(name="is_read", required=True)

src/snek/service/__init__.py

@@ -1,21 +1,20 @@
 import functools
 
 from snek.service.channel import ChannelService
-from snek.service.user import UserService
 from snek.service.channel_member import ChannelMemberService
-from types import SimpleNamespace
+from snek.service.user import UserService
-
 from snek.system.object import Object
 
+
 @functools.cache
 def get_services(app):
     return Object(
         **{
             "user": UserService(app=app),
             "channel_member": ChannelMemberService(app=app),
-            'channel': ChannelService(app=app)
+            "channel": ChannelService(app=app),
         }
-)
+    )
 
 
 def get_service(name, app=None):

src/snek/service/channel.py

@@ -1,31 +1,48 @@
 from snek.system.service import BaseService
 
+
 class ChannelService(BaseService):
     mapper_name = "channel"
 
-    async def create(self, label, created_by_uid,  description=None, tag=None, is_private=False, is_listed=True):
+    async def create(
+        self,
+        label,
+        created_by_uid,
+        description=None,
+        tag=None,
+        is_private=False,
+        is_listed=True,
+    ):
         if label[0] != "#" and is_listed:
             label = f"#{label}"
         count = await self.count(deleted_at=None)
         if not tag and not count:
             tag = "public"
         model = await self.new()
-        model['label'] = label
+        model["label"] = label
-        model['description'] = description
+        model["description"] = description
-        model['tag'] = tag 
+        model["tag"] = tag
-        model['created_by_uid'] = created_by_uid
+        model["created_by_uid"] = created_by_uid
-        model['is_private'] = is_private
+        model["is_private"] = is_private
-        model['is_listed'] = is_listed
+        model["is_listed"] = is_listed
         if await self.save(model):
             return model
         raise Exception(f"Failed to create channel: {model.errors}.")
-    
+
     async def ensure_public_channel(self, created_by_uid):
-        model = await self.get(is_listed=True,tag="public")
+        model = await self.get(is_listed=True, tag="public")
-        is_moderator = False 
+        is_moderator = False
         if not model:
-            is_moderator = True 
+            is_moderator = True
-            model = await self.create("public", created_by_uid=created_by_uid, is_listed=True, tag="public")
+            model = await self.create(
-        await self.app.services.channel_member.create(model['uid'], created_by_uid, is_moderator=is_moderator, is_read_only=False, is_muted=False, is_banned=False)
+                "public", created_by_uid=created_by_uid, is_listed=True, tag="public"
+            )
+        await self.app.services.channel_member.create(
+            model["uid"],
+            created_by_uid,
+            is_moderator=is_moderator,
+            is_read_only=False,
+            is_muted=False,
+            is_banned=False,
+        )
         return model
-    

src/snek/service/channel_member.py

@@ -1,24 +1,33 @@
-from snek.system.service import BaseService 
+from snek.system.service import BaseService
+
 
 class ChannelMemberService(BaseService):
 
     mapper_name = "channel_member"
 
-    async def create(self, channel_uid, user_uid, is_moderator=False, is_read_only=False, is_muted=False, is_banned=False):
+    async def create(
+        self,
+        channel_uid,
+        user_uid,
+        is_moderator=False,
+        is_read_only=False,
+        is_muted=False,
+        is_banned=False,
+    ):
         model = await self.get(channel_uid=channel_uid, user_uid=user_uid)
         if model:
             if model.is_banned.value:
-                return False 
+                return False
             return model
         model = await self.new()
         channel = await self.services.channel.get(uid=channel_uid)
-        model['label'] = channel['label']
+        model["label"] = channel["label"]
-        model['channel_uid'] = channel_uid
+        model["channel_uid"] = channel_uid
-        model['user_uid'] = user_uid
+        model["user_uid"] = user_uid
-        model['is_moderator'] = is_moderator
+        model["is_moderator"] = is_moderator
-        model['is_read_only'] = is_read_only
+        model["is_read_only"] = is_read_only
-        model['is_muted'] = is_muted
+        model["is_muted"] = is_muted
-        model['is_banned'] = is_banned
+        model["is_banned"] = is_banned
         if await self.save(model):
             return model
-        raise Exception(f"Failed to create channel member: {model.errors}.")
+        raise Exception(f"Failed to create channel member: {model.errors}.")

src/snek/service/channel_message.py

@@ -6,9 +6,9 @@ class ChannelMessageService(BaseService):
 
     async def create(self, channel_uid, user_uid, message):
         model = await self.new()
-        model['channel_uid'] = channel_uid
+        model["channel_uid"] = channel_uid
-        model['user_uid'] = user_uid
+        model["user_uid"] = user_uid
-        model['message'] = message
+        model["message"] = message
         if await self.save(model):
             return model
-        raise Exception(f"Failed to create channel message: {model.errors}.")
+        raise Exception(f"Failed to create channel message: {model.errors}.")

src/snek/service/notification.py

@@ -1,5 +1,3 @@
-
-
 from snek.system.service import BaseService
 
 
@@ -8,23 +6,32 @@ class NotificationService(BaseService):
 
     async def create(self, object_uid, object_type, user_uid, message):
         model = await self.new()
-        model['object_uid'] = object_uid
+        model["object_uid"] = object_uid
-        model['object_type'] = object_type
+        model["object_type"] = object_type
-        model['user_uid'] = user_uid
+        model["user_uid"] = user_uid
-        model['message'] = message
+        model["message"] = message
         if await self.save(model):
             return model
         raise Exception(f"Failed to create notification: {model.errors}.")
-    
+
     async def create_channel_message(self, channel_message_uid):
-        channel_message = await self.services.channel_message.get(uid=channel_message_uid)
+        channel_message = await self.services.channel_message.get(
-        user = await self.services.user.get(uid=channel_message['user_uid'])
+            uid=channel_message_uid
-        async for channel_member in self.services.channel_member.find(channel_uid=channel_message['channel_uid'],is_banned=False,is_muted=False, deleted_at=None):
+        )
+        user = await self.services.user.get(uid=channel_message["user_uid"])
+        async for channel_member in self.services.channel_member.find(
+            channel_uid=channel_message["channel_uid"],
+            is_banned=False,
+            is_muted=False,
+            deleted_at=None,
+        ):
             model = await self.new()
-            model['object_uid'] = channel_message_uid
+            model["object_uid"] = channel_message_uid
-            model['object_type'] = "channel_message"
+            model["object_type"] = "channel_message"
-            model['user_uid'] = channel_member['user_uid']
+            model["user_uid"] = channel_member["user_uid"]
-            model['message'] = f"New message from {user['nick']} in {channel_member['label']}."
+            model["message"] = (
+                f"New message from {user['nick']} in {channel_member['label']}."
+            )
             if await self.save(model):
                 return model
             raise Exception(f"Failed to create notification: {model.errors}.")

src/snek/service/user.py

@@ -17,13 +17,15 @@ class UserService(BaseService):
         if await self.exists(username=username):
             raise Exception("User already exists.")
         model = await self.new()
-        model['nick'] = username
+        model["nick"] = username
         model.email.value = email
         model.username.value = username
         model.password.value = await security.hash(password)
         if await self.save(model):
             if model:
-                channel = await self.services.channel.ensure_public_channel(model['uid'])
+                channel = await self.services.channel.ensure_public_channel(
+                    model["uid"]
+                )
                 if not channel:
                     raise Exception("Failed to create public channel.")
             return model

src/snek/system/cache.py

@@ -1,35 +1,36 @@
 import functools
 import json
-import uuid 
+
-from snek.system import security 
+from snek.system import security
 
 cache = functools.cache
 
-CACHE_MAX_ITEMS_DEFAULT=5000
+CACHE_MAX_ITEMS_DEFAULT = 5000
+
 
 class Cache:
-    def __init__(self, app,max_items=CACHE_MAX_ITEMS_DEFAULT):
+    def __init__(self, app, max_items=CACHE_MAX_ITEMS_DEFAULT):
         self.app = app
         self.cache = {}
         self.max_items = max_items
         self.lru = []
-        self.version = ((42+420+1984+1990+10+6+71+3004+7245)^1337)+4
+        self.version = ((42 + 420 + 1984 + 1990 + 10 + 6 + 71 + 3004 + 7245) ^ 1337) + 4
 
     async def get(self, args):
         try:
             self.lru.pop(self.lru.index(args))
         except:
-            print("Cache miss!",args,flush=True)
+            print("Cache miss!", args, flush=True)
             return None
         self.lru.insert(0, args)
-        while(len(self.lru) > self.max_items):
+        while len(self.lru) > self.max_items:
             self.cache.pop(self.lru[-1])
             self.lru.pop()
-        print("Cache hit!",args,flush=True)
+        print("Cache hit!", args, flush=True)
         return self.cache[args]
 
     def json_default(self, value):
-        #if hasattr(value, "to_json"):
+        # if hasattr(value, "to_json"):
         #    return value.to_json()
         try:
             return json.dumps(value.__dict__, default=str)
@@ -37,59 +38,64 @@ class Cache:
             return str(value)
 
     async def create_cache_key(self, args, kwargs):
-        return await security.hash(json.dumps({"args": args, "kwargs": kwargs}, sort_keys=True,default=self.json_default))
+        return await security.hash(
+            json.dumps(
+                {"args": args, "kwargs": kwargs},
+                sort_keys=True,
+                default=self.json_default,
+            )
+        )
 
     async def set(self, args, result):
-        is_new = not args in self.cache
+        is_new = args not in self.cache
         self.cache[args] = result
         try:
             self.lru.pop(self.lru.index(args))
-        except(ValueError, IndexError):
+        except (ValueError, IndexError):
-            pass 
+            pass
-        self.lru.insert(0,args)
+        self.lru.insert(0, args)
 
-        while(len(self.lru) > self.max_items):
+        while len(self.lru) > self.max_items:
             self.cache.pop(self.lru[-1])
             self.lru.pop()
 
         if is_new:
             self.version += 1
-            print("New version:",self.version,flush=True)
+            print("New version:", self.version, flush=True)
 
     async def delete(self, args):
-        if args in self.cache:  
+        if args in self.cache:
             try:
                 self.lru.pop(self.lru.index(args))
             except IndexError:
-                pass 
+                pass
             del self.cache[args]
 
-    def async_cache(self,func):
+    def async_cache(self, func):
         @functools.wraps(func)
-        async def wrapper(*args,**kwargs):
+        async def wrapper(*args, **kwargs):
-            cache_key = await self.create_cache_key(args,kwargs)
+            cache_key = await self.create_cache_key(args, kwargs)
             cached = await self.get(cache_key)
             if cached:
                 return cached
-            result = await func(*args,**kwargs)
+            result = await func(*args, **kwargs)
-            await self.set(cache_key,result)
+            await self.set(cache_key, result)
             return result
+
         return wrapper
 
-
+    def async_delete_cache(self, func):
-
-    def async_delete_cache(self,func):
         @functools.wraps(func)
-        async def wrapper(*args,**kwargs):
+        async def wrapper(*args, **kwargs):
-            cache_key = await self.create_cache_key(args,kwargs)
+            cache_key = await self.create_cache_key(args, kwargs)
             if cache_key in self.cache:
                 try:
                     self.lru.pop(self.lru.index(cache_key))
                 except IndexError:
-                    pass 
+                    pass
                 del self.cache[cache_key]
             return await func(*args, **kwargs)
-            
+
         return wrapper
 
 

src/snek/system/object.py

@@ -1,15 +1,13 @@
-
-
 class Object:
-    
+
     def __init__(self, *args, **kwargs):
         for arg in args:
-            if isinstance(arg,dict):
+            if isinstance(arg, dict):
                 self.__dict__.update(arg)
         self.__dict__.update(kwargs)
-    
+
     def __getitem__(self, key):
         return self.__dict__[key]
-    
+
     def __setitem__(self, key, value):
-        self.__dict__[key] = value
+        self.__dict__[key] = value

src/snek/system/service.py

@@ -7,10 +7,10 @@ class BaseService:
 
     mapper_name: BaseMapper = None
 
-    @property 
+    @property
     def services(self):
-        return self.app.services 
+        return self.app.services
-    
+
     def __init__(self, app):
         self.app = app
         self.cache = app.cache
@@ -19,11 +19,11 @@ class BaseService:
         else:
             self.mapper = None
 
-    async def exists(self,uid=None, **kwargs):
+    async def exists(self, uid=None, **kwargs):
         if uid:
             if not kwargs and await self.cache.get(uid):
-                return True 
+                return True
-            kwargs['uid'] = uid
+            kwargs["uid"] = uid
         return await self.count(**kwargs) > 0
 
     async def count(self, **kwargs):
@@ -32,24 +32,24 @@ class BaseService:
     async def new(self, **kwargs):
         return await self.mapper.new()
 
-    async def get(self,uid=None, **kwargs):
+    async def get(self, uid=None, **kwargs):
         if uid:
             if not kwargs:
                 result = await self.cache.get(uid)
                 if result:
                     return result
-            kwargs['uid'] = uid 
+            kwargs["uid"] = uid
-            
+
         result = await self.mapper.get(**kwargs)
         if result:
-            await self.cache.set(result['uid'], result)
+            await self.cache.set(result["uid"], result)
         return result
 
     async def save(self, model: UserModel):
         # if model.is_valid: You Know why not
-        if  await self.mapper.save(model):
+        if await self.mapper.save(model):
-            await self.cache.set(model['uid'], model)
+            await self.cache.set(model["uid"], model)
-            return True 
+            return True
         errors = await model.errors
         raise Exception(f"Couldn't save model. Errors: f{errors}")
 

src/snek/system/view.py

@@ -20,8 +20,8 @@ class BaseView(web.View):
     def db(self):
         return self.app.db
 
-    async def json_response(self, data,**kwargs):
+    async def json_response(self, data, **kwargs):
-        return web.json_response(data,**kwargs)
+        return web.json_response(data, **kwargs)
 
     @property
     def session(self):

src/snek/view/login.py

@@ -1,6 +1,8 @@
+from aiohttp import web
+
 from snek.form.login import LoginForm
-from snek.system.view import BaseFormView, BaseView
+from snek.system.view import BaseFormView
-from aiohttp import web 
+
 
 class LoginView(BaseFormView):
     form = LoginForm
@@ -10,9 +12,7 @@ class LoginView(BaseFormView):
             return web.HTTPFound("/web.html")
         if self.request.path.endswith(".json"):
             return await super().get()
-        return await self.render_template(
+        return await self.render_template("login.html")
-            "login.html"
-        )  
 
     async def submit(self, form):
         if await form.is_valid:
@@ -21,5 +21,3 @@ class LoginView(BaseFormView):
             self.session["uid"] = form.uid.value
             return {"redirect_url": "/web.html"}
         return {"is_valid": False}
-
-    

src/snek/view/register.py

@@ -1,12 +1,13 @@
-from snek.form.register import RegisterForm
-from snek.system.view import BaseFormView, BaseView
 from aiohttp import web
 
+from snek.form.register import RegisterForm
+from snek.system.view import BaseFormView
+
+
 class RegisterView(BaseFormView):
 
     form = RegisterForm
 
-
     async def get(self):
         if self.session.get("logged_in"):
             return web.HTTPFound("/web.html")

src/snek/view/status.py

@@ -1,31 +1,46 @@
 from snek.system.view import BaseView
-import json
+
 
 class StatusView(BaseView):
     async def get(self):
-        
+
         memberships = []
         user = {}
-        
+
         if self.session.get("uid"):
             user = await self.app.services.user.get(uid=self.session.get("uid"))
             if not user:
                 return await self.json_response({"error": "User not found"}, status=404)
-            async for model in self.app.services.channel_member.find(user_uid=self.session.get("uid"),deleted_at=None,is_banned=False):
+            async for model in self.app.services.channel_member.find(
-                channel = await self.app.services.channel.get(uid=model['channel_uid'])
+                user_uid=self.session.get("uid"), deleted_at=None, is_banned=False
-                memberships.append(dict(name=channel['label'],description=model['description'],user_uid=model['user_uid'],is_moderator=model['is_moderator'],is_read_only=model['is_read_only'],is_muted=model['is_muted'],is_banned=model['is_banned'],channel_uid=model['channel_uid'],uid=model['uid']))
+            ):
-            user = dict(
+                channel = await self.app.services.channel.get(uid=model["channel_uid"])
-                username=user['username'],
+                memberships.append(
-                email=user['email'],
+                    {
-                nick=user['nick'],
+                        "name": channel["label"],
-                uid=user['uid'],
+                        "description": model["description"],
-                memberships=memberships
+                        "user_uid": model["user_uid"],
-            )
+                        "is_moderator": model["is_moderator"],
-        
+                        "is_read_only": model["is_read_only"],
+                        "is_muted": model["is_muted"],
+                        "is_banned": model["is_banned"],
+                        "channel_uid": model["channel_uid"],
+                        "uid": model["uid"],
+                    }
+                )
+            user = {
+                "username": user["username"],
+                "email": user["email"],
+                "nick": user["nick"],
+                "uid": user["uid"],
+                "memberships": memberships,
+            }
 
         return await self.json_response(
             {
                 "user": user,
-                "cache": await self.app.cache.create_cache_key(self.app.cache.cache,None)
+                "cache": await self.app.cache.create_cache_key(
+                    self.app.cache.cache, None
+                ),
             }
         )