Project structure:

DarkBot/
├── darkData.py
├── darkbot.py
├── filters.py
└── worker.py


Project files:

darkbot.py
```py
import asyncio
import logging
import sys
from typing import Union

import aiogram
from aiogram import Bot, Dispatcher, types
from aiogram.client.default import DefaultBotProperties
from aiogram.enums import ParseMode
from aiogram.filters import Command, BaseFilter
from aiogram.types import Message

from DarkBot.darkData import DarkData
from DarkBot.filters import DarkCommand, DarkFilter


class DarkBot:
    def __init__(
        self,
        token: str
    ):
        self.bot = Bot(
            token=token,
            default=DefaultBotProperties(parse_mode=ParseMode.HTML)
        )

        self.aiogram_dispatcher = Dispatcher()

    # Ваши собственные декораторы
    def message(self, filter: Union[DarkFilter, BaseFilter]):
        def decorator(func):
            print(f"tyyyyyype: {type(filter)}")
            if isinstance(filter, DarkFilter):
                aiogram_filter = filter.get_inst()
            elif isinstance(filter, Command):
                aiogram_filter = filter
            else:
                raise TypeError("Invalid filter type. Must be DarkFilter or aiogram.filters.BaseFilter.")

            @self.aiogram_dispatcher.message(aiogram_filter)
            async def wrapper(message: types.Message):
                print("cmmdd!")
                return await func(DarkData(message))

            return wrapper

        return decorator


    def start(self, is_logging=False):
        """
        starts the bot with asyncio

        :param logging:
        :return:
        """
        async def main() -> None:
            await self.aiogram_dispatcher.start_polling(self.bot)

        if is_logging:
            logging.basicConfig(level=logging.INFO, stream=sys.stdout)

        asyncio.run(main())


```


darkData.py
```py
from typing import TYPE_CHECKING
from aiogram.types import Message

if TYPE_CHECKING:
    from aiogram import Bot

class DarkUser:
    def __init__(self, aiogram_user):
        user_id = aiogram_user.id
        self.data = {}
        self.id = user_id

class DarkData:
    def __init__(self, message: Message):
        self.user = DarkUser(message.from_user)
        self.message: Message = message
```


filters.py
```py
from typing import Optional, List

from aiogram.filters import BaseFilter, Command


class DarkFilter:
    def get_inst(self) -> BaseFilter:
        raise NotImplementedError("You must implement get_inst() for your specific logic")


class DarkCommand(DarkFilter):
    def __init__(
            self,
            commands: List[str],  # Используем List[str] для type hinting
            prefix: str = "/"

    ):
        self.commands = commands
        self.prefix = prefix

    def get_inst(self) -> Command: # Указываем возвращаемый тип Command
        return Command(commands=self.commands, prefix=self.prefix)
```


worker.py
```py
# Ваши собственные декораторы
def on_start():
    def decorator(func):
        @_dp.message(Command("start"))
        async def wrapper(message: Message):
            print("start!")  # Ваш дополнительный код, если нужен
            return await func(message)
        return wrapper
    return decorator

def on_help():
    def decorator(func):
        @_dp.message(Command("help"))
        async def wrapper(message: Message):
            return await func(message)
        return wrapper
    return decorator
```


Я разрабатываю свой фреймворк для простого создания телеграм ботов на основе aiogram.
Основная идея заключается в том, чтобы все декораторы возвращали DarkData, в котором будет простое сообщение aiogram, а также класс User, в котором будет все нуное и удобное.
Например, я хочу сделать так, чтобы был метод .set_val(), который бы принимал что угодно(2 аргумента, ключ-значение).
Напеиши мне пожалуйста отдельный класс бд sqlite3, который бы создавал .db пользователей, где бы был id и значение darkdata(json).
Должны быть высокоуровневые методы, способные, как я описал выше, просто добавлять и получать значения непосредственно в User.
Это будет очень удобно, т.к. в телеграмме нет переменных пользователей.

Все должно рабоатть максимально быстро и рассчитано на большой параллельный трафик. Должна быть асинхронность.

Можешь пожалуйста продумать что еще можно добавить в класс User, чего не хватало бы в обычном aiogram и что было бы дико удобно.
Спасибо!