refactored

base/exceptions.py

@@ -0,0 +1,26 @@
+from graphql import GraphQLError
+
+
+class BaseHttpException(GraphQLError):
+    code = 500
+    message = "500 Server error"
+
+
+class InvalidToken(BaseHttpException):
+    code = 403
+    message = "403 Invalid Token"
+
+
+class ObjectNotExist(BaseHttpException):
+    code = 404
+    message = "404 Object Does Not Exist"
+
+
+class OperationNotAllowed(BaseHttpException):
+    code = 403
+    message = "403 Operation is not allowed"
+
+
+class InvalidPassword(BaseHttpException):
+    code = 401
+    message = "401 Invalid Password"

base/orm.py

@@ -0,0 +1,56 @@
+from typing import TypeVar, Any, Dict, Generic, Callable
+
+from sqlalchemy import create_engine, Column, Integer
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import Session
+from sqlalchemy.sql.schema import Table
+
+from settings import DB_URL
+
+if DB_URL.startswith('sqlite'):
+	engine = create_engine(DB_URL)
+else:
+	engine = create_engine(DB_URL, convert_unicode=True, echo=False, \
+		pool_size=10, max_overflow=20)
+
+T = TypeVar("T")
+
+REGISTRY: Dict[str, type] = {}
+
+def local_session():
+	return Session(bind=engine, expire_on_commit=False)
+
+
+class Base(declarative_base()):
+	__table__: Table
+	__tablename__: str
+	__new__: Callable
+	__init__: Callable
+
+	__abstract__: bool = True
+	__table_args__ = {"extend_existing": True}
+	id: int = Column(Integer, primary_key=True)
+
+	def __init_subclass__(cls, **kwargs):
+		REGISTRY[cls.__name__] = cls
+
+	@classmethod
+	def create(cls: Generic[T], **kwargs) -> Generic[T]:
+		instance = cls(**kwargs)
+		return instance.save()
+
+	def save(self) -> Generic[T]:
+		with local_session() as session:
+			session.add(self)
+			session.commit()
+		return self
+
+	def update(self, input):
+		column_names = self.__table__.columns.keys()
+		for (name, value) in input.items():
+			if name in column_names:
+				setattr(self, name, value)
+
+	def dict(self) -> Dict[str, Any]:
+		column_names = self.__table__.columns.keys()
+		return {c: getattr(self, c) for c in column_names}

base/redis.py

@@ -0,0 +1,58 @@
+import aioredis
+from settings import REDIS_URL
+
+
+class Redis:
+	def __init__(self, uri=REDIS_URL):
+		self._uri: str = uri
+		self._instance = None
+
+	async def connect(self):
+		if self._instance is not None:
+			return
+		self._instance = aioredis.from_url(self._uri, encoding="utf-8")
+
+	async def disconnect(self):
+		if self._instance is None:
+			return
+		self._instance.close()
+		await self._instance.wait_closed()
+		self._instance = None
+
+	async def execute(self, command, *args, **kwargs):
+		return await self._instance.execute_command(command, *args, **kwargs)
+
+	async def lrange(self, key, start, stop):
+		return await self._instance.lrange(key, start, stop)
+
+	async def mget(self, key, *keys):
+		return await self._instance.mget(key, *keys)
+
+
+async def test():
+	redis = Redis()
+	from datetime import datetime
+
+	await redis.connect()
+	await redis.execute("SET", "1-KEY1", 1)
+	await redis.execute("SET", "1-KEY2", 1)
+	await redis.execute("SET", "1-KEY3", 1)
+	await redis.execute("SET", "1-KEY4", 1)
+	await redis.execute("EXPIREAT", "1-KEY4", int(datetime.utcnow().timestamp()))
+	v = await redis.execute("KEYS", "1-*")
+	print(v)
+	await redis.execute("DEL", *v)
+	v = await redis.execute("KEYS", "1-*")
+	print(v)
+
+
+if __name__ == '__main__':
+	import asyncio
+
+	asyncio.run(test())
+
+
+redis = Redis()
+
+__all__ = ['redis']
+

base/resolvers.py

@@ -0,0 +1,15 @@
+from ariadne import MutationType, QueryType, SubscriptionType, ScalarType
+
+
+query = QueryType()
+mutation = MutationType()
+subscription = SubscriptionType()
+
+
+datetime_scalar = ScalarType("DateTime")
+
+@datetime_scalar.serializer
+def serialize_datetime(value):
+	return value.isoformat()
+
+resolvers = [query, mutation, subscription, datetime_scalar]