Rewriting of type hintings.

Author: Tim-ats-d

.gitignore

@@ -1,2 +1,5 @@
 .vscode
 .idea
+
+# Sphinx documentation
+/doc/build/

visualdialog/box.py

@@ -25,7 +25,9 @@
 import curses.textpad
 from typing import List, Tuple, Union
 
-from .utils import (CursesKeyConstants,
+from .utils import (CursesKeyConstant,
+                    CursesKeyConstants,
+                    CursesTextAttributesConstant,
                     CursesTextAttributesConstants,
                     TextAttributes)
 
@@ -38,7 +40,7 @@ class PanicError(Exception):
     :type key: CursesKeyConstants
     """
     def __init__(self,
-                 key: CursesKeyConstants):
+                 key: CursesKeyConstant):
         self.key = key
 
     def __str__(self):
@@ -49,8 +51,8 @@ class TextBox:
     """This class provides attributs and methods to manage a text box.
 
     .. NOTE::
-        This class provides a general API for text boxes, it does not need
-        to be instantiated.
+        This class provides a general API for text boxes, it does not
+        need to be instantiated.
 
     :param pos_x: x position of the dialog box in ``curses`` window
         object on which methods will have effects.
@@ -72,31 +74,31 @@ class TextBox:
         of dialog box.
         If title is an empty string, the title will not be displayed.
         This defaults an empty string.
-    :type title: Optional[str]
+    :type title: str
 
     :param title_colors_pair_nb:
         Number of the curses color pair that will be used to color the
         title. Zero corresponding to the pair of white color on black
         background initialized by ``curses``). This defaults to ``0``.
-    :type title_colors_pair_nb: Optional[int]
+    :type title_colors_pair_nb: int
 
     :param title_text_attr:
         Dialog box title text attributes. It should be a single curses
         text attribute or a tuple of curses text attribute. This
         defaults to ``curses.A_BOLD``.
-    :type title_text_attr: Optional[Union[CursesTextAttributesConstants,tuple[CursesTextAttributesConstants],list[CursesTextAttributesConstants]]]
+    :type title_text_attr: Union[CursesTextAttributesConstant,CursesTextAttributesConstants]
 
     :param downtime_chars:
         List of characters that will trigger a ``downtime_chars_delay``
         time second between the writing of each character.
         This defaults to ``(",", ".", ":", ";", "!", "?")``.
-    :type downtime_chars: Optional[Union[tuple[str],list[str]]]
+    :type downtime_chars: Union[tuple[str],list[str]]
 
     :param downtime_chars_delay:
         Waiting time in seconds after writing a character contained in
         ``downtime_chars``.
         This defaults to ``0.6``.
-    :type downtime_chars_delay: Optional[Union[int,float]]
+    :type downtime_chars_delay: Union[int,float]
     """
 
     def __init__(
@@ -106,10 +108,9 @@ def __init__(
         length: int,
         width: int,
         title: str = "",
-        title_colors_pair_nb: CursesTextAttributesConstants = 0,
-        title_text_attr: Union[CursesTextAttributesConstants,
-                               Tuple[CursesTextAttributesConstants],
-                               List[CursesTextAttributesConstants]] = curses.A_BOLD,
+        title_colors_pair_nb: int = 0,
+        title_text_attr: Union[CursesTextAttributesConstant,
+                               CursesTextAttributesConstants] = curses.A_BOLD,
         downtime_chars: Union[Tuple[str],
                               List[str]] = (",", ".", ":", ";", "!", "?"),
         downtime_chars_delay: Union[int, float] = .6):
@@ -140,27 +141,25 @@ def __init__(
         self.downtime_chars_delay = downtime_chars_delay
 
         #: List of accepted key codes to skip dialog. ``curses`` constants are supported. This defaults to an empty tuple.
-        self.confirm_dialog_key: Union[Tuple[CursesKeyConstants],
-                                       List[CursesKeyConstants]] = ()
+        self.confirm_dialog_key: List[CursesKeyConstants] = []
         #: List of accepted key codes to raise PanicError. ``curses`` constants are supported. This defaults to an empty tuple.
-        self.panic_key: Union[Tuple[CursesKeyConstants],
-                              List[CursesKeyConstants]] = ()
+        self.panic_key: List[CursesKeyConstants] = []
 
     @property
-    def position(self) -> Tuple[int, int]:
+    def position(self) -> Tuple[int]:
         """Returns a tuple contains x;y position of ``TextBox``.
 
         :returns: x;y position of ``TextBox``.
-        :rtype: tuple[int, int]
+        :rtype: tuple[int]
         """
         return self.text_pos_x - 2, self.text_pos_y - 3
 
     @property
-    def dimensions(self) -> Tuple[int, int]:
+    def dimensions(self) -> Tuple[int]:
         """Returns a tuple contains dimensions of ``TextBox``.
 
         :returns: Length and width of ``TextBox``.
-        :rtype: tuple[int, int]
+        :rtype: tuple[int]
         """
         return self.length, self.width
 

visualdialog/choices.py

@@ -30,27 +30,9 @@
 
 class ChoiceBox(DialogBox):
 
-    def __init__(
-            self,
-            pos_x: int,
-            pos_y: int,
-            box_length: int,
-            box_width: int,
-            title: str = "",
-            title_colors_pair_nb: CursesTextAttributesConstants = 0,
-            title_text_attributes: Tuple[CursesTextAttributesConstants] = (
-                curses.A_BOLD, ),
-            downtime_chars: Tuple[str] = (",", ".", ":", ";", "!", "?"),
-            downtime_chars_delay: Union[int, float] = 0.6):
-        super().__init__(pos_x,
-                         pos_y,
-                         box_length,
-                         box_width,
-                         title,
-                         title_colors_pair_nb,
-                         title_text_attributes,
-                         downtime_chars,
-                         downtime_chars_delay)
+    def __init__(self,
+                 **kwargs):
+        super().__init__(**kwargs)
 
     def chain(
             self,

visualdialog/dialog.py

@@ -28,7 +28,8 @@
 from typing import Callable, Dict, List, Optional, Tuple, Union
 
 from .box import TextBox
-from .utils import (CursesTextAttributesConstants,
+from .utils import (CursesTextAttributesConstant,
+                    CursesTextAttributesConstants,
                     TextAttributes,
                     _make_chunk)
 
@@ -43,11 +44,12 @@ class DialogBox(TextBox):
         to ``"►"``.
     :type end_dialog_indicator: str
 
-    :key kwargs: Keyword arguments correspond to the instance attributes of
-        ``TextBox``.
+    :key kwargs: Keyword arguments correspond to the instance attributes
+        of ``TextBox``.
 
     .. NOTE::
-        This class inherits all the methods and attributes of ``TextBox``.
+        This class inherits all the methods and attributes of
+        ``TextBox``.
 
     .. WARNING::
         Parameters ``downtime_chars`` and ``downtime_chars_delay`` do
@@ -78,8 +80,8 @@ def __exit__(self, type, value, traceback):
     def _display_end_dialog_indicator(
         self,
         stdscr,
-        text_attr: Optional[Union[Tuple[CursesTextAttributesConstants], List[CursesTextAttributesConstants]]] = (
-            curses.A_BOLD, curses.A_BLINK)):
+        text_attr: CursesTextAttributesConstants = (curses.A_BOLD,
+                                                    curses.A_BLINK)):
         """Displays an end of dialog indicator in the lower right corner
         of textbox.
 
@@ -89,7 +91,7 @@ def _display_end_dialog_indicator(
         :param text_attr: Text attributes of
             ``end_dialog_indicator`` method. This defaults to
             ``(curses.A_BOLD, curses.A_BLINK)``.
-        :type text_attr: Optional[Union[tuple[CursesTextAttributesConstants],list[CursesTextAttributesConstants]]]
+        :type text_attr: CursesTextAttributesConstants
         """
         if self.end_dialog_indicator_char:
             with TextAttributes(stdscr, *text_attr):
@@ -102,15 +104,13 @@ def char_by_char(
         stdscr,
         text: str,
         colors_pair_nb: int = 0,
-        text_attr: Union[CursesTextAttributesConstants,
-                         Tuple[CursesTextAttributesConstants],
-                         List[CursesTextAttributesConstants]] = (),
-        words_attr: Union[Dict[Tuple[str], CursesTextAttributesConstants],
-                          Dict[Tuple[str],
-                               Tuple[CursesTextAttributesConstants]]] = {},
+        text_attr: Union[CursesTextAttributesConstant,
+                         CursesTextAttributesConstants] = (),
+        words_attr: Union[Dict[Tuple[str], CursesTextAttributesConstant],
+                          Dict[Tuple[str], CursesTextAttributesConstants]] = {},
         flash_screen: bool = False,
         delay: Union[int, float] = .04,
-        random_delay: Tuple[float, float] = (0, 0),
+        random_delay: Union[Tuple[int, float], List[int, float]] = (0, 0),
         callback: Callable = lambda: None,
         cargs: Union[Tuple, List] = ()):
         """Writes the given text character by character in the current
@@ -129,40 +129,40 @@ def char_by_char(
             corresponding to the pair of white color on black
             background initialized by ``curses``). This defaults to
             ``0``.
-        :type colors_pair_nb: Optional[int]
+        :type colors_pair_nb: int
 
         :param text_attr: Dialog box curses text attributes. It should
             be a single curses text attribute or a tuple of curses text
             attribute. This defaults an empty tuple.
-        :type text_attr: Optional[Union[CursesTextAttributesConstants,tuple[CursesTextAttributesConstants],list[CursesTextAttributesConstants]]]
+        :type text_attr: Union[CursesTextAttributesConstant,CursesTextAttributesConstants]
 
         :param words_attr: This defaults to an empty dictionary.
-        :type words_atttr: Union[Dict[tuple[str],CursesTextAttributesConstants],Dict[tuple[str],tuple[CursesTextAttributesConstants]]]
+        :type words_atttr: Union[dict[Tuple[str], CursesTextAttributesConstant],dict[Tuple[str], CursesTextAttributesConstants]]
 
         :param flash_screen: Allows or not to flash screen with a short
             light effect done before writing the first character by
             ``flash`` function from ``curses`` module. This defaults to
             ``False``.
-        :type flash_screen: Optional[bool]
+        :type flash_screen: bool
 
         :param delay: Waiting time between the writing of each character
             of text in second. This defaults to ``0.04``.
-        :type delay: Optional[Union[int, float]]
+        :type delay: Union[int, float]
 
         :param random_delay: Waiting time between the writing of each
             character in seconds where time waited is a random number
             generated in ``random_delay`` interval. This defaults to
             ``(0, 0)``.
-        :type random_delay: Optional[tuple[float, flot],list[float, float]]
+        :type random_delay: Union[tuple[int, float],list[int, float]]
 
         :param callback: Callable called after writing a character and
             the delay time has elapsed. This defaults to a lambda which
             do nothing.
-        :type callback: Optional[Callable]
+        :type callback: Callable
 
         :param cargs: All the arguments that will be passed to callback.
             This defaults to an empty tuple.
-        :type cargs: Optional[Union[tuple[Any],list[Any]]]
+        :type cargs: Union[tuple,list]
 
         .. NOTE::
             Method flow:
@@ -182,7 +182,8 @@ def char_by_char(
             If the volume of text displayed is too large to be contained
             in a dialog box, text will be automatically cut into
             paragraphs using ``textwrap.wrap`` function. See
-            `textwrap module documentation <https://docs.python.org/fr/3.8/library/textwrap.html#textwrap.wrap>`_.
+            `textwrap module documentation
+            <https://docs.python.org/fr/3.8/library/textwrap.html#textwrap.wrap>`_.
             for more information of the behavior of text wrap.
 
         .. WARNING::
@@ -248,15 +249,13 @@ def word_by_word(
         text: str,
         colors_pair_nb: int = 0,
         cut_char: str = " ",
-        text_attr: Union[CursesTextAttributesConstants,
-                         Tuple[CursesTextAttributesConstants],
-                         List[CursesTextAttributesConstants]] = (),
-        words_attr: Union[Dict[Tuple[str], CursesTextAttributesConstants],
-                          Dict[Tuple[str],
-                               Tuple[CursesTextAttributesConstants]]] = {},
+        text_attr: Union[CursesTextAttributesConstant,
+                         CursesTextAttributesConstants] = (),
+        words_attr: Union[Dict[Tuple[str], CursesTextAttributesConstant],
+                          Dict[Tuple[str], CursesTextAttributesConstants]] = {},
         flash_screen: bool = False,
         delay: Union[int, float] = .15,
-        random_delay: Tuple[float, float] = (0, 0),
+        random_delay: Union[Tuple[int, float], List[int, float]] = (0, 0),
         callback: Callable = lambda: None,
         cargs: Union[Tuple, List] = ()):
         """Writes the given text word by word at position in the current
@@ -275,15 +274,15 @@ def word_by_word(
             the text. The number zero corresponding to the pair of
             white color on black background initialized by ``curses``).
             This defaults to ``0``.
-        :type colors_pair_nb: Optional[int]
+        :type colors_pair_nb: int
 
         :param text_attr: Dialog box curses text attributes. It should
             be a single curses text attribute or a tuple of curses text
             attribute. This defaults an empty tuple.
-        :type text_attr: Optional[Union[CursesTextAttributesConstants,tuple[CursesTextAttributesConstants],list[CursesTextAttributesConstants]]]
+        :type text_attr: Union[CursesTextAttributesConstant,CursesTextAttributesConstants]
 
         :param words_attr: This defaults to an empty dictionary.
-        :type words_atttr: Union[Dict[tuple[str],CursesTextAttributesConstants],Dict[tuple[str],tuple[CursesTextAttributesConstants]]]
+        :type words_atttr: Union[dict[Tuple[str], CursesTextAttributesConstant],dict[Tuple[str], CursesTextAttributesConstants]]
 
         :param cut_char: The delimiter according which to split the text
             in word. This defaults to ``" "``.
@@ -293,26 +292,26 @@ def word_by_word(
             light effect done before writing the first character by
             ``flash`` function from ``curses`` module. This defaults to
             ``False``.
-        :type flash_screen: Optional[bool]
+        :type flash_screen: bool
 
         :param delay: Waiting time between the writing of each word of
             ``text`` in second. This defaults to ``0.15``.
-        :type delay: Optional[Union[int, float]]
+        :type delay: Union[int, float]
 
         :param random_delay: Waiting time between the writing of each
             word in seconds where time waited is a random number
             generated in ``random_delay`` interval. This defaults to
             ``(0, 0)``.
-        :type random_delay: Optional[tuple[float, float],list[float, float]]
+        :type random_delay: Union[tuple[int, float],list[int, float]]
 
         :param callback: Callable called after writing a word and the
             delay time has elapsed. This defaults to a lambda which do
             nothing.
-        :type callback: Optional[Callable]
+        :type callback: Callable
 
         :param cargs: All the arguments that will be passed to callback.
             This defaults to an empty tuple.
-        :type cargs: Optional[Union[tuple[Any],list[Any]]]
+        :type cargs: Union[tuple,list]
 
         .. NOTE::
             Method flow:
@@ -333,7 +332,8 @@ def word_by_word(
             If the volume of text displayed is too large to be contained
             in a dialog box, text will be automatically cut into
             paragraphs using ``textwrap.wrap`` function. See
-            `textwrap module documentation <https://docs.python.org/fr/3.8/library/textwrap.html#textwrap.wrap>`_
+            `textwrap module documentation
+            <https://docs.python.org/fr/3.8/library/textwrap.html#textwrap.wrap>`_
             for more information of the behavior of text wrap.
 
         .. WARNING::

visualdialog/utils.py

@@ -24,11 +24,14 @@
 
 # curses text attribute constants are integers.
 # See https://docs.python.org/3/library/curses.html?#constants
-CursesTextAttributesConstants = int
+CursesTextAttributesConstant = int
+CursesTextAttributesConstants = Union[Tuple[int], List[int]]
 
 # curses key constants are integers.
 # See https://docs.python.org/3/library/curses.html?#constants
-CursesKeyConstants = int
+CursesKeyConstant = int
+CursesKeyConstants = Union[Tuple[int], List[int]]
+
 
 def _make_chunk(iterable: Union[Tuple, List],
                 chunk_length: int) -> Generator: