keyboa.keyboards

Complexity

Total Complexity

28

Size/Duplication

Total Lines	191
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	Keyboa.combine()	0	28	4
A	Keyboa.convert_items_to_buttons()	0	13	1
A	Keyboa.verify_preformatted_items()	0	9	3
A	Keyboa.merge_keyboards_data()	0	19	4
A	Keyboa.alignment_range()	0	13	3
A	Keyboa.keyboa()	0	6	1
A	Keyboa._generated_keyboa()	0	15	2
A	Keyboa._calculated_items_in_row()	0	14	3
A	Keyboa._verified_items_in_row()	0	12	3
A	Keyboa._preformatted_keyboa()	0	11	2
A	Keyboa.slice()	0	16	2

# -*- coding:utf-8 -*-
"""
This module contains all the necessary functions for
creating complex and functional inline keyboards.
"""


from typing import Union, Optional, Tuple
from telebot.types import InlineKeyboardMarkup

from keyboa.base import Base
from keyboa.button import Button
from keyboa.constants import (
    DEFAULT_ITEMS_IN_LINE,
    AUTO_ALIGNMENT_RANGE,
)


class Keyboa(Base):
    """Default Keyboa class"""

    def slice(
        self,
        slice_: slice = slice(None, None, None),
    ) -> InlineKeyboardMarkup:
        """
        :return:
        """
        self._items_sliced = self.items[slice_]

        keyboard = (
            self._generated_keyboa
            if self.items_in_row or self.alignment
            else self._preformatted_keyboa
        )
        self._items_sliced = None
        return keyboard

    @property
    def keyboa(self) -> InlineKeyboardMarkup:
        """
        :return:
        """
        return self.slice()

    @property
    def _calculated_items_in_row(self) -> Optional[int]:
        """
        :return:
        """

        items_in_row = None

        for divider in self.alignment_range:
            if not len(self._items_sliced) % divider:
                items_in_row = divider
                break

        return items_in_row

    @property
    def _verified_items_in_row(self) -> int:
        """
        :return:
        """
        items_in_row = None
        if self.alignment:
            items_in_row = self._calculated_items_in_row

        if not items_in_row:
            items_in_row = DEFAULT_ITEMS_IN_LINE
        return items_in_row

    @property
    def alignment_range(self):
        """
        :return:
        """

        alignment_range = (
            AUTO_ALIGNMENT_RANGE if isinstance(self.alignment, bool) else self.alignment
        )
        return (
            reversed(alignment_range)
            if self.alignment_reverse_range
            else alignment_range
        )

    @property
    def _preformatted_keyboa(self) -> InlineKeyboardMarkup:
        """
        :return:
        """
        self.verify_preformatted_items()
        keyboard = InlineKeyboardMarkup()
        for row in self._items_sliced:
            buttons = self.convert_items_to_buttons(row)
            keyboard.row(*buttons)
        return keyboard

    def verify_preformatted_items(self) -> None:
        """
        Check that every row in kb is a list
        :return:
        """
        for index, item in enumerate(self._items_sliced):
            if not isinstance(item, list):
                self._items_sliced[index] = [
                    item,
                ]

    def convert_items_to_buttons(self, items) -> list:
        """
        :param items:
        :return:
        """
        return [
            Button(
                button_data=item,
                front_marker=self.front_marker,
                back_marker=self.back_marker,
                copy_text_to_callback=self.copy_text_to_callback,
            ).generate()
            for item in items
        ]

    @property
    def _generated_keyboa(self) -> InlineKeyboardMarkup:
        """
        :return:
        """
        keyboard = InlineKeyboardMarkup()
        items_in_row = self._verified_items_in_row
        rows_in_keyboard = len(self._items_sliced) // items_in_row
        buttons = self.convert_items_to_buttons(self._items_sliced)

        for _row in range(rows_in_keyboard):
            keyboard.row(*[buttons.pop(0) for _button in range(items_in_row)])
        keyboard.row(*buttons)

        return keyboard

    @staticmethod
    def merge_keyboards_data(keyboards):
        """
        :param keyboards:
        :return:
        """
        data = []
        for keyboard in keyboards:
            if keyboard is None:
                continue

            if not isinstance(keyboard, InlineKeyboardMarkup):
                type_error_message = (
                    "Keyboard cannot be %s. Only InlineKeyboardMarkup allowed."
                    % type(keyboard)
                )
                raise TypeError(type_error_message)
            data.extend(keyboard.keyboard)
        return data

    @classmethod
    def combine(
        cls,
        keyboards: Optional[
            Union[Tuple[InlineKeyboardMarkup, ...], InlineKeyboardMarkup]
        ] = None,
    ) -> InlineKeyboardMarkup:
        """
        This function combines multiple InlineKeyboardMarkup objects into one.

        :param keyboards: Sequence of InlineKeyboardMarkup objects.
            Also could be presented as a standalone InlineKeyboardMarkup.

        :return: InlineKeyboardMarkup
        """

        if keyboards is None:
            return InlineKeyboardMarkup()

        if isinstance(keyboards, InlineKeyboardMarkup):
            keyboards = (keyboards,)

        for keyboard in keyboards:
            cls.is_keyboard_proper_type(keyboard)

        data = cls.merge_keyboards_data(keyboards)

        return cls(items=data).keyboa