format and lint orm

base/orm.py

@@ -5,50 +5,52 @@ 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)
+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)
+    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)
+    return Session(bind=engine, expire_on_commit=False)
 
 
 class Base(declarative_base()):
-	__table__: Table
-	__tablename__: str
-	__new__: Callable
-	__init__: Callable
+    __table__: Table
+    __tablename__: str
+    __new__: Callable
+    __init__: Callable
 
-	__abstract__: bool = True
-	__table_args__ = {"extend_existing": True}
-	id: int = Column(Integer, primary_key=True)
+    __abstract__: bool = True
+    __table_args__ = {"extend_existing": True}
+    id: int = Column(Integer, primary_key=True)
 
-	def __init_subclass__(cls, **kwargs):
-		REGISTRY[cls.__name__] = cls
+    def __init_subclass__(cls, **kwargs):
+        REGISTRY[cls.__name__] = cls
 
-	@classmethod
-	def create(cls: Generic[T], **kwargs) -> Generic[T]:
-		instance = cls(**kwargs)
-		return instance.save()
+    @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 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 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}
+    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

@@ -1,34 +1,34 @@
 import aioredis
 from settings import REDIS_URL
 
+
 class Redis:
-	def __init__(self, uri=REDIS_URL):
-		self._uri: str = uri
-		self._instance = None
+    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 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 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 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 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 mget(self, key, *keys):
+        return await self._instance.mget(key, *keys)
 
 
 redis = Redis()
 
-__all__ = ['redis']
-
+__all__ = ["redis"]

base/resolvers.py

@@ -3,9 +3,11 @@ from ariadne import MutationType, QueryType, SubscriptionType, ScalarType
 
 datetime_scalar = ScalarType("DateTime")
 
+
 @datetime_scalar.serializer
 def serialize_datetime(value):
-	return value.isoformat()
+    return value.isoformat()
+
 
 query = QueryType()
 mutation = MutationType()