помогите с созданием календаря в айограмме питона

подскажите пожалуйста .как мне перенести код находящийся в файле с ботом в файл генерирующий группу кнопок.чтобы я его мог использовать как можно минимум писав кода в основном файле. Вот мой файл с ботом.

bot.py.

from calendar_my import Calendar
bot = Bot(token=BOT_TOKEN)
dp = Dispatcher(bot, storage=MemoryStorage())
dp.middleware.setup(LoggingMiddleware())
cal = Calendar()
# функция для создания описания напоминания
@dp.message_handler(state='state_add_description_reminder')
async def func_reminder_create_description(message: types.Message, state: FSMContext):
    if func_id_admin(message.from_user.id):
        await state.update_data(description=message.text)
        await bot.send_message(message.from_user.id, "выберите когда напомнить")
        await bot.send_message(message.from_user.id, "календарь",
                               reply_markup=cal.calendar(int_year=0, int_month=0))
        await state.set_state('state_add_date_reminder')

# функция для создания времени напоминания
# функция обрабатывающая нажатия на календаре
int_year_initial = {'year': 0}
int_month_initial = {'month': 0}

@dp.callback_query_handler(lambda c: c.data and c.data.startswith('calendar_'), state='state_add_date_reminder')
async def func_date(callback_query: types.CallbackQuery, state: FSMContext):
    if func_id_admin(callback_query.from_user.id):
        code = callback_query.data.replace('calendar_', '')
        if code == 'year_forward':
            if int_year_initial['year'] < 1:
                int_year_initial['year'] = int_year_initial['year'] + 1
                # await bot.edit_message_reply_markup()
                await bot.delete_message(callback_query.from_user.id, callback_query.message.message_id)
                await bot.send_message(callback_query.from_user.id, "календарь",
                                       reply_markup=cal.calendar(int_year_initial['year'], int_month_initial['month']))
        elif code == 'year_back':
            if int_year_initial['year'] > 0:
                int_year_initial['year'] = int_year_initial['year'] - 1
                await bot.delete_message(callback_query.from_user.id, callback_query.message.message_id)
                await bot.send_message(callback_query.from_user.id, "календарь",
                                       reply_markup=cal.calendar(int_year_initial['year'], int_month_initial['month']))
        elif code == 'month_forward':
            if int_month_initial['month'] < 11:
                int_month_initial['month'] = int_month_initial['month'] + 1
                await bot.delete_message(callback_query.from_user.id, callback_query.message.message_id)
                await bot.send_message(callback_query.from_user.id, "календарь",
                                       reply_markup=cal.calendar(int_year_initial['year'], int_month_initial['month']))

        elif code == 'month_back':
            if int_month_initial['month'] > 0:
                int_month_initial['month'] = int_month_initial['month'] - 1
                await bot.delete_message(callback_query.from_user.id, callback_query.message.message_id)
                await bot.send_message(callback_query.from_user.id, "календарь",
                                       reply_markup=cal.calendar(int_year_initial['year'], int_month_initial['month']))
        else:
            await bot.delete_message(callback_query.from_user.id, callback_query.message.message_id)
            await state.update_data(date=str(code) + '_' +
                                    cal.months[int_month_initial['month']] + '_' +
                                    str(cal.years[int_year_initial['year']]))
            user_data = await state.get_data()
            await bot.send_message(callback_query.from_user.id, user_data['name'] + '   ' +
                                   user_data['description'] + '   ' + user_data['date'])
            await state.set_state('state_add_time_reminder')

есть файл генерирующий календарь calendar_my.py

from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton

class Calendar:
    json_calendar = {2020: {
        'январь': {1: 3, 'дней': 31},
        'февраль': {1: 6, 'дней': 29},
        'март': {1: 7, 'дней': 31},
        'апрель': {1: 3, 'дней': 30},
        'май': {1: 5, 'дней': 31},
        'июнь': {1: 1, 'дней': 30},
        'июль': {1: 3, 'дней': 31},
        'август': {1: 6, 'дней': 31},
        'сентябрь': {1: 2, 'дней': 30},
        'октябрь': {1: 4, 'дней': 31},
        'ноябрь': {1: 7, 'дней': 30},
        'декабрь': {1: 2, 'дней': 31}
    }, 2021: {
        'январь': {1: 6, 'дней': 31},
        'февраль': {1: 1, 'дней': 29},
        'март': {1: 1, 'дней': 31},
        'апрель': {1: 4, 'дней': 30},
        'май': {1: 6, 'дней': 31},
        'июнь': {1: 2, 'дней': 30},
        'июль': {1: 4, 'дней': 31},
        'август': {1: 7, 'дней': 31},
        'сентябрь': {1: 3, 'дней': 30},
        'октябрь': {1: 5, 'дней': 31},
        'ноябрь': {1: 1, 'дней': 30},
        'декабрь': {1: 3, 'дней': 31}
    }}
    years = [2020, 2021]
    days_of_the_week = ['понедельник', 'вторник', 'среда',
                        'четверг', 'пятница', 'суббота', 'воскресенье']
    months = ['январь', 'февраль', 'март', 'апрель', 'май', 'июнь',
              'июль', 'август', 'сентябрь', 'октябрь', 'ноябрь', 'декабрь']
    hours = 24
    minutes = 60

    def calendar(self, int_year, int_month):
        self.year = self.years[int_year]
        self.month = self.months[int_month]
        self.in_btn_calendar_year_forward = InlineKeyboardButton('следующий', callback_data='calendar_year_forward')
        self.in_btn_calendar_year_current = InlineKeyboardButton(str(self.years[int_year]), callback_data='ррр')
        self.in_btn_calendar_year_back = InlineKeyboardButton('предыдущий', callback_data='calendar_year_back')
        self.in_btn_calendar_month_forward = InlineKeyboardButton('следующий', callback_data='calendar_month_forward')
        self.in_btn_calendar_month_current = InlineKeyboardButton(self.months[int_month], callback_data='ллл')
        self.in_btn_calendar_month_back = InlineKeyboardButton('предыдущий', callback_data='calendar_month_back')
        self.in_group_btn_calendar = InlineKeyboardMarkup(row_width=7)
        # in_group_btn_calendar.clean()
        x = self.json_calendar[self.year][self.month][1]
        for day_week in self.days_of_the_week:
            self.in_group_btn_calendar.insert(InlineKeyboardButton(day_week, callback_data='day_week_' + day_week))
        for day_empty in range(self.json_calendar[self.year][self.month][1] - 1):
            self.in_group_btn_calendar.insert(InlineKeyboardButton('*', callback_data='day_week_' + str(day_empty)))
        for day in range(self.json_calendar[self.year][self.month]['дней']):
            day_of_the_week = self.days_of_the_week[((day + x) % 7) - 1]
            # print(str(year) + '_' + month + '_' + str(day + 1) + '_' + day_of_the_week)
            self.in_group_btn_calendar.insert(InlineKeyboardButton(str(day + 1), callback_data='calendar_' + str(day + 1)))
        for day_empty in range((42 - (self.json_calendar[self.year][self.month]['дней'] +
                                self.json_calendar[self.year][self.month][1] - 1)) % 7):
            self.in_group_btn_calendar.insert(InlineKeyboardButton('*', callback_data='day_week_' + str(day_empty)))
        self.in_group_btn_calendar.row(self.in_btn_calendar_year_back, self.in_btn_calendar_year_current, self.in_btn_calendar_year_forward)
        self.in_group_btn_calendar.row(self.in_btn_calendar_month_back, self.in_btn_calendar_month_current, self.in_btn_calendar_month_forward)
        return self.in_group_btn_calendar

    def clock(self, int_hour, int_minute):
        self.in_btn_calendar_hour_forward = InlineKeyboardButton('следующий', callback_data='calendar_year_forward')
        self.in_btn_calendar_hour_current = InlineKeyboardButton(str(self.years[int_year]), callback_data='ррр')
        self.in_btn_calendar_hour_back = InlineKeyboardButton('предыдущий', callback_data='calendar_year_back')
        self.in_btn_calendar_month_forward = InlineKeyboardButton('следующий', callback_data='calendar_month_forward')
        self.in_btn_calendar_month_current = InlineKeyboardButton(self.months[int_month], callback_data='ллл')
        self.in_btn_calendar_month_back = InlineKeyboardButton('предыдущий', callback_data='calendar_month_back')
        self.in_group_btn_calendar = InlineKeyboardMarkup(row_width=7)

как сделать так чтобы файл генерирующий календарь мог сам обрабатывать свои хендлеры? Или как сделать календарь , чтобы этот файл можно было с легкостью использовать в других проектах?

у меня получилось только вот так .если кто может подсказать , как это сделать еще более удобней. я новичок .и

# функция для создания описания напоминания
@dp.message_handler(state='state_add_description_reminder')
async def func_reminder_create_description(message: types.Message, state: FSMContext):
    if func_id_admin(message.from_user.id):
        await state.update_data(description=message.text)
        await bot.send_message(message.from_user.id, "выберите дату")
        await bot.send_message(message.from_user.id, "календарь",
                               reply_markup=cal.calendar(int_year=0, int_month=0))
        await state.set_state('state_add_date_reminder')

# функция для создания времени напоминания

@dp.callback_query_handler(lambda c: c.data and c.data.startswith('calendar_'),  state='state_add_date_reminder')
async def func_date(callback_query: types.CallbackQuery, state: FSMContext):
    if func_id_admin(callback_query.from_user.id):
        cal_cm = cal.calendar_command(callback_query, state)
        if isinstance(cal_cm, Iterable):
            for aw in cal_cm:
                await aw
            user_data = await state.get_data()
            if 'date' in user_data:
                await bot.send_message(callback_query.from_user.id, user_data['date'])
                await bot.send_message(callback_query.from_user.id, 'выберите время')
                await bot.send_message(callback_query.from_user.id, "часы",
                                       reply_markup=cal.clock(int_hour=0, int_minute=0))
                await state.set_state('state_add_time_reminder')


@dp.callback_query_handler(lambda c: c.data and c.data.startswith('clock_'), state='state_add_time_reminder')
async def func_time(callback_query: types.CallbackQuery, state: FSMContext):
    if func_id_admin(callback_query.from_user.id):
        cl_cm = cal.clock_command(callback_query, state)
        if isinstance(cl_cm, Iterable):
            for aw in cl_cm:
                await aw
            user_data = await state.get_data()
            if 'time' in user_data:
                await bot.send_message(callback_query.from_user.id, user_data['time'])
                await bot.send_message(callback_query.from_user.id, str(user_data))

calendar_my.py

 from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton

class Calendar:

    def __init__(self, bot, dp):
        self.bot = bot
        self.dp = dp

    int_initial = {'year': 0, 'month': 0, 'hour': 0, 'minute': 0}

    json_calendar = {2020: {
        'январь': {1: 3, 'дней': 31},
        'февраль': {1: 6, 'дней': 29},
        'март': {1: 7, 'дней': 31},
        'апрель': {1: 3, 'дней': 30},
        'май': {1: 5, 'дней': 31},
        'июнь': {1: 1, 'дней': 30},
        'июль': {1: 3, 'дней': 31},
        'август': {1: 6, 'дней': 31},
        'сентябрь': {1: 2, 'дней': 30},
        'октябрь': {1: 4, 'дней': 31},
        'ноябрь': {1: 7, 'дней': 30},
        'декабрь': {1: 2, 'дней': 31}
    }, 2021: {
        'январь': {1: 6, 'дней': 31},
        'февраль': {1: 1, 'дней': 29},
        'март': {1: 1, 'дней': 31},
        'апрель': {1: 4, 'дней': 30},
        'май': {1: 6, 'дней': 31},
        'июнь': {1: 2, 'дней': 30},
        'июль': {1: 4, 'дней': 31},
        'август': {1: 7, 'дней': 31},
        'сентябрь': {1: 3, 'дней': 30},
        'октябрь': {1: 5, 'дней': 31},
        'ноябрь': {1: 1, 'дней': 30},
        'декабрь': {1: 3, 'дней': 31}
    }}
    years = [2020, 2021]
    days_of_the_week = ['понедельник', 'вторник', 'среда',
                        'четверг', 'пятница', 'суббота', 'воскресенье']
    months = ['январь', 'февраль', 'март', 'апрель', 'май', 'июнь',
              'июль', 'август', 'сентябрь', 'октябрь', 'ноябрь', 'декабрь']
    hours = 24
    minutes = 60

    # функция обрабатывающая нажатия на календаре
    def calendar_command(self, callback_query, state):
        code = callback_query.data.replace('calendar_', '')
        if code == 'year_forward':
            if self.int_initial['year'] < 1:
                self.int_initial['year'] = self.int_initial['year'] + 1
                return self.bot.delete_message(callback_query.from_user.id, callback_query.message.message_id),\
                    self.bot.send_message(callback_query.from_user.id, "календарь",
                                          reply_markup=self.calendar(self.int_initial['year'],
                                                                     self.int_initial['month']))
        elif code == 'year_back':
            if self.int_initial['year'] > 0:
                self.int_initial['year'] = self.int_initial['year'] - 1
                return self.bot.delete_message(callback_query.from_user.id, callback_query.message.message_id),\
                    self.bot.send_message(callback_query.from_user.id, "календарь",
                                          reply_markup=self.calendar(self.int_initial['year'],
                                                                     self.int_initial['month']))
        elif code == 'month_forward':
            if self.int_initial['month'] < 11:
                self.int_initial['month'] = self.int_initial['month'] + 1
                return self.bot.delete_message(callback_query.from_user.id, callback_query.message.message_id),\
                    self.bot.send_message(callback_query.from_user.id, "календарь",
                                          reply_markup=self.calendar(self.int_initial['year'],
                                                                     self.int_initial['month']))

        elif code == 'month_back':
            if self.int_initial['month'] > 0:
                self.int_initial['month'] = self.int_initial['month'] - 1
                return self.bot.delete_message(callback_query.from_user.id, callback_query.message.message_id),\
                    self.bot.send_message(callback_query.from_user.id, "календарь",
                                          reply_markup=self.calendar(self.int_initial['year'],
                                                                     self.int_initial['month']))
        else:
            return self.bot.delete_message(callback_query.from_user.id, callback_query.message.message_id),\
                    state.update_data(date=str(code) + '_' +
                                      self.months[self.int_initial['month']] + '_' +
                                      str(self.years[self.int_initial['year']]))
    # метод генерирующий календарь
    def calendar(self, int_year, int_month):
        self.year = self.years[int_year]
        self.month = self.months[int_month]
        self.in_btn_calendar_year_forward = InlineKeyboardButton('следующий', callback_data='calendar_year_forward')
        self.in_btn_calendar_year_current = InlineKeyboardButton(str(self.years[int_year]), callback_data='ррр')
        self.in_btn_calendar_year_back = InlineKeyboardButton('предыдущий', callback_data='calendar_year_back')
        self.in_btn_calendar_month_forward = InlineKeyboardButton('следующий', callback_data='calendar_month_forward')
        self.in_btn_calendar_month_current = InlineKeyboardButton(self.months[int_month], callback_data='ллл')
        self.in_btn_calendar_month_back = InlineKeyboardButton('предыдущий', callback_data='calendar_month_back')
        self.in_group_btn_calendar = InlineKeyboardMarkup(row_width=7)
        # in_group_btn_calendar.clean()
        x = self.json_calendar[self.year][self.month][1]
        for day_week in self.days_of_the_week:
            self.in_group_btn_calendar.insert(InlineKeyboardButton(day_week, callback_data='day_week_' + day_week))
        for day_empty in range(self.json_calendar[self.year][self.month][1] - 1):
            self.in_group_btn_calendar.insert(InlineKeyboardButton('*', callback_data='day_week_' + str(day_empty)))
        for day in range(self.json_calendar[self.year][self.month]['дней']):
            day_of_the_week = self.days_of_the_week[((day + x) % 7) - 1]
            # print(str(year) + '_' + month + '_' + str(day + 1) + '_' + day_of_the_week)
            self.in_group_btn_calendar.insert(InlineKeyboardButton(str(day + 1), callback_data='calendar_' + str(day + 1)))
        for day_empty in range((42 - (self.json_calendar[self.year][self.month]['дней'] +
                                self.json_calendar[self.year][self.month][1] - 1)) % 7):
            self.in_group_btn_calendar.insert(InlineKeyboardButton('*', callback_data='day_week_' + str(day_empty)))
        self.in_group_btn_calendar.row(self.in_btn_calendar_year_back, self.in_btn_calendar_year_current, self.in_btn_calendar_year_forward)
        self.in_group_btn_calendar.row(self.in_btn_calendar_month_back, self.in_btn_calendar_month_current, self.in_btn_calendar_month_forward)
        return self.in_group_btn_calendar

    # функция обрабатывающая нажатия на часы
    def clock_command(self, callback_query, state):
        code = callback_query.data.replace('clock_', '')
        if code == 'hour_forward_1':
            if self.int_initial['hour'] < 23:
                self.int_initial['hour'] = self.int_initial['hour'] + 1
                return self.bot.delete_message(callback_query.from_user.id, callback_query.message.message_id), \
                    self.bot.send_message(callback_query.from_user.id, "часы",
                                          reply_markup=self.clock(self.int_initial['hour'],
                                                                  self.int_initial['minute']))
        elif code == 'hour_forward_6':
            if self.int_initial['hour'] < 18:
                self.int_initial['hour'] = self.int_initial['hour'] + 6
                return self.bot.delete_message(callback_query.from_user.id, callback_query.message.message_id), \
                    self.bot.send_message(callback_query.from_user.id, "часы",
                                          reply_markup=self.clock(self.int_initial['hour'],
                                                                  self.int_initial['minute']))
        elif code == 'hour_back_1':
            if self.int_initial['hour'] > 0:
                self.int_initial['hour'] = self.int_initial['hour'] - 1
                return self.bot.delete_message(callback_query.from_user.id, callback_query.message.message_id), \
                    self.bot.send_message(callback_query.from_user.id, "часы",
                                          reply_markup=self.clock(self.int_initial['hour'],
                                                                  self.int_initial['minute']))
        elif code == 'hour_back_6':
            if self.int_initial['hour'] > 5:
                self.int_initial['hour'] = self.int_initial['hour'] - 6
                return self.bot.delete_message(callback_query.from_user.id, callback_query.message.message_id), \
                    self.bot.send_message(callback_query.from_user.id, "часы",
                                          reply_markup=self.clock(self.int_initial['hour'],
                                                                  self.int_initial['minute']))
        elif code == 'minute_forward_1':
            if self.int_initial['minute'] < 60:
                self.int_initial['minute'] = self.int_initial['minute'] + 1
                return self.bot.delete_message(callback_query.from_user.id, callback_query.message.message_id), \
                    self.bot.send_message(callback_query.from_user.id, "часы",
                                          reply_markup=self.clock(self.int_initial['hour'],
                                                                  self.int_initial['minute']))
        elif code == 'minute_forward_10':
            if self.int_initial['minute'] < 50:
                self.int_initial['minute'] = self.int_initial['minute'] + 10
                return self.bot.delete_message(callback_query.from_user.id, callback_query.message.message_id), \
                    self.bot.send_message(callback_query.from_user.id, "часы",
                                          reply_markup=self.clock(self.int_initial['hour'],
                                                                  self.int_initial['minute']))

        elif code == 'minute_back_1':
            if self.int_initial['minute'] > 0:
                self.int_initial['minute'] = self.int_initial['minute'] - 1
                return self.bot.delete_message(callback_query.from_user.id, callback_query.message.message_id), \
                    self.bot.send_message(callback_query.from_user.id, "часы",
                                          reply_markup=self.clock(self.int_initial['hour'],
                                                                  self.int_initial['minute']))
        elif code == 'minute_back_10':
            if self.int_initial['minute'] > 9:
                self.int_initial['minute'] = self.int_initial['minute'] - 10
                return self.bot.delete_message(callback_query.from_user.id, callback_query.message.message_id), \
                    self.bot.send_message(callback_query.from_user.id, "часы",
                                          reply_markup=self.clock(self.int_initial['hour'],
                                                                  self.int_initial['minute']))
        elif code == 'confirm':
            return self.bot.delete_message(callback_query.from_user.id, callback_query.message.message_id), \
                    state.update_data(time=str(self.int_initial['hour']) + '_' + str(self.int_initial['minute']))

    def clock(self, int_hour, int_minute):
        self.in_btn_empty = InlineKeyboardButton('*', callback_data='jjj')
        self.in_btn_clock_hour_forward_1 = InlineKeyboardButton('+1', callback_data='clock_hour_forward_1')
        self.in_btn_clock_hour_forward_6 = InlineKeyboardButton('+6', callback_data='clock_hour_forward_6')
        self.in_btn_clock_hour_current = InlineKeyboardButton(str(int_hour), callback_data='ррр')
        self.in_btn_clock_hour_back_1 = InlineKeyboardButton('-1', callback_data='clock_hour_back_1')
        self.in_btn_clock_hour_back_6 = InlineKeyboardButton('-6', callback_data='clock_hour_back_6')
        self.in_btn_clock_minute_forward_1 = InlineKeyboardButton('+1', callback_data='clock_minute_forward_1')
        self.in_btn_clock_minute_forward_10 = InlineKeyboardButton('+10', callback_data='clock_minute_forward_10')
        self.in_btn_clock_minute_current = InlineKeyboardButton(str(int_minute), callback_data='ллл')
        self.in_btn_clock_minute_back_1 = InlineKeyboardButton('-1', callback_data='clock_minute_back_1')
        self.in_btn_clock_minute_back_10 = InlineKeyboardButton('-10', callback_data='clock_minute_back_10')
        self.in_btn_clock_confirm = InlineKeyboardButton('установить время', callback_data='clock_confirm')
        self.in_group_btn_clock = InlineKeyboardMarkup()
        self.in_group_btn_clock.row(self.in_btn_clock_hour_back_6,self.in_btn_clock_hour_back_1,
                                    self.in_btn_clock_hour_current, self.in_btn_clock_hour_forward_1,
                                    self.in_btn_clock_hour_forward_6)
        self.in_group_btn_clock.row(self.in_btn_clock_minute_back_10,self.in_btn_clock_minute_back_1,
                                    self.in_btn_clock_minute_current, self.in_btn_clock_minute_forward_1,
                                    self.in_btn_clock_minute_forward_10)
        self.in_group_btn_clock.row(self.in_btn_clock_confirm)
        return self.in_group_btn_clock