pymenu-cli 1.0.6__tar.gz → 1.0.7__tar.gz

{pymenu_cli-1.0.6 → pymenu-cli-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymenu-cli
-Version: 1.0.6
+Version: 1.0.7
 Summary: A Python library for creating interactive CLI menus
 Home-page: https://github.com/moraneus/pymenu-cli
 Author: Moraneus
@@ -18,6 +18,13 @@ Requires-Dist: art
 
 pymenu-cli is a Python library that simplifies the creation of interactive command-line interface (CLI) menus. It provides a convenient way to define hierarchical menu structures and associate actions with menu items.
 
+<video width="320" height="240" autoplay loop muted>
+  <source src="docs/example.mp4" type="video/mp4">
+  Your browser does not support the video tag.
+</video>
+
+
+
 ## Features
 
 - Define menus and submenus using a simple JSON file format
@@ -42,8 +49,9 @@ pip install pymenu-cli
 2. Implement the corresponding action functions in a separate Python file (`actions.py`)
 
 ### Using the Python API
+
 ```python
-from pymenu_cli.pymenu import load_menu
+from pymenu_cli.menu import load_menu
 
 # Define the 'menu' and the 'action' files 
 menu_file_path = 'menu.json'
@@ -275,3 +283,77 @@ python3 menu_example.py
 
 ### License
 This project is licensed under the MIT License.
+
+## Contributors
+# Contributing to pymenu-cli
+
+Thank you for considering contributing to pymenu-cli! We welcome all contributions, whether they are bug reports, feature requests, or code improvements. Please take a moment to review this document before submitting your contributions.
+
+## How to Contribute
+
+### Reporting Bugs
+
+If you find a bug, please report it by [opening an issue](https://github.com/moraneus/pymenu-cli/issues). Include as much detail as possible to help us reproduce and fix the issue quickly. Make sure to include:
+
+- A clear and descriptive title.
+- A detailed description of the problem.
+- Steps to reproduce the issue.
+- Any relevant logs or screenshots.
+
+### Suggesting Enhancements
+
+We welcome suggestions for new features and enhancements. To suggest an enhancement, please [open an issue](https://github.com/moraneus/pymenu-cli/issues) and provide:
+
+- A clear and descriptive title.
+- A detailed description of the proposed enhancement.
+- Any relevant examples or mockups.
+
+### Submitting Pull Requests
+
+To submit a pull request (PR), follow these steps:
+
+1. **Fork the repository**: Click the "Fork" button at the top of this page to create a copy of the repository on your GitHub account.
+
+2. **Clone your fork**: Clone the forked repository to your local machine using the following command:
+    ```bash
+    git clone https://github.com/moraneus/pymenu-cli.git
+    cd pymenu-cli
+    ```
+
+3. **Create a new branch**: Create a new branch for your work. Use a descriptive name for the branch:
+    ```bash
+    git checkout -b feature/my-new-feature
+    ```
+
+4. **Make your changes**: Make your changes in the new branch.
+
+5. **Commit your changes**: Commit your changes with a clear and concise commit message:
+    ```bash
+    git add .
+    git commit -m "Add feature: my new feature"
+    ```
+
+6. **Push to your fork**: Push your changes to your forked repository:
+    ```bash
+    git push origin feature/my-new-feature
+    ```
+
+7. **Open a pull request**: Go to the original repository and open a pull request from your forked repository. Provide a clear and descriptive title and description for your PR.
+
+### Code Style and Guidelines
+
+- Follow the existing code style and conventions.
+- Write clear and concise commit messages.
+- Write tests for new features and bug fixes.
+- Ensure your code passes all existing tests.
+
+### Running Tests
+
+Before submitting your PR, make sure all tests pass. You can run the tests using the following commands:
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run tests
+pytest

{pymenu_cli-1.0.6 → pymenu-cli-1.0.7}/README.md

@@ -6,6 +6,13 @@
 
 pymenu-cli is a Python library that simplifies the creation of interactive command-line interface (CLI) menus. It provides a convenient way to define hierarchical menu structures and associate actions with menu items.
 
+<video width="320" height="240" autoplay loop muted>
+  <source src="docs/example.mp4" type="video/mp4">
+  Your browser does not support the video tag.
+</video>
+
+
+
 ## Features
 
 - Define menus and submenus using a simple JSON file format
@@ -30,8 +37,9 @@ pip install pymenu-cli
 2. Implement the corresponding action functions in a separate Python file (`actions.py`)
 
 ### Using the Python API
+
 ```python
-from pymenu_cli.pymenu import load_menu
+from pymenu_cli.menu import load_menu
 
 # Define the 'menu' and the 'action' files 
 menu_file_path = 'menu.json'

pymenu-cli-1.0.7/pymenu_cli/__init__.py

@@ -0,0 +1 @@
+from .pymenu import main

pymenu-cli-1.0.7/pymenu_cli/models/menu.py

@@ -0,0 +1,158 @@
+"""
+This module defines the Menu class, which represents a text-based menu system.
+"""
+
+import os
+import sys
+from typing import Optional, List, Dict
+
+import art
+
+from pymenu_cli.ui.styles import Styles, TextColors, BackgroundColors
+from pymenu_cli.models.menu_item import MenuItem
+
+
+class Menu:
+    """Represents a menu.
+
+    Attributes:
+        __m_title (str): The title of the menu.
+        __m_items (List[MenuItem]): A list of items in the menu.
+        __m_actions (Optional[object]): An object containing callable actions.
+        __m_color (Optional[Dict]): The color settings for the menu title.
+        __m_banner (Optional[Dict]): The banner for the menu.
+    """
+
+    def __init__(self, i_title: str, i_config: Optional[Dict] = None):
+        """
+        Initialize the Menu instance.
+
+        Args:
+            i_title (str): The title of the menu.
+            i_config (Optional[Dict]): A dictionary containing optional settings for items,
+                                     actions, color, and banner.
+        """
+        i_config = i_config or {}
+        self.__m_title = i_title
+        self.__m_items = i_config.get('items', [])
+        self.__m_actions = i_config.get('actions')
+        self.__m_color = i_config.get('color')
+        self.__m_banner = i_config.get('banner')
+
+    @property
+    def title(self) -> str:
+        """
+        Gets the title of the menu item.
+
+        Returns:
+            str: The title of the menu item.
+        """
+        return self.__m_title
+
+    @property
+    def color(self) -> Optional[Dict]:
+        """
+        Gets the color settings of the menu item.
+
+        Returns:
+            Optional[Dict]: The color settings of the menu item.
+        """
+        return self.__m_color
+
+    @property
+    def items(self) -> List[MenuItem]:
+        """
+        Gets the items in the menu.
+
+        Returns:
+            List[MenuItem]: A list of items in the menu.
+        """
+        return self.__m_items
+
+    @property
+    def actions(self) -> Optional[object]:
+        """
+        Gets the actions associated with the menu.
+
+        Returns:
+            Optional[object]: An object containing callable actions.
+        """
+        return self.__m_actions
+
+    @property
+    def banner(self) -> Optional[Dict]:
+        """
+        Gets the banner for the menu.
+
+        Returns:
+            Optional[Dict]: The banner for the menu.
+        """
+        return self.__m_banner
+
+    def add_item(self, item: MenuItem) -> None:
+        """Adds an item to the menu.
+
+        Args:
+            item (MenuItem): The item to add.
+        """
+        self.__m_items.append(item)
+
+    def display(self) -> None:
+        """Displays the menu and handles user input."""
+        while True:
+            os.system('cls' if os.name == 'nt' else 'clear')
+
+            if self.__m_banner:
+                self.print_banner()
+
+            title_color = Menu.get_color_string(self.__m_color)
+            print(f"\n{title_color}{self.__m_title}{Styles.RESET_ALL}\n")
+
+            for i, item in enumerate(self.__m_items, start=1):
+                item_color = self.get_color_string(item.color)
+                print(f"{i}. {item_color}{item.title}{Styles.RESET_ALL}")
+
+            print("\nB. Back")
+            print("X. Exit")
+
+            choice = input("\nEnter your choice: ").upper()
+
+            if choice == 'B':
+                return
+            if choice == 'X':
+                sys.exit()
+            try:
+                index = int(choice) - 1
+                if 0 <= index < len(self.__m_items):
+                    selected_item = self.__m_items[index]
+                    if selected_item.submenu:
+                        selected_item.submenu.display()
+                    elif selected_item.action:
+                        getattr(self.__m_actions, selected_item.action)()
+                else:
+                    raise ValueError
+            except (ValueError, IndexError):
+                input("\nInvalid choice. Press Enter to try again.")
+
+    def print_banner(self) -> None:
+        """Prints the banner using the art library."""
+        banner_text = self.__m_banner.get('title', '')
+        banner_font = self.__m_banner.get('font', 'standard')
+        banner = art.text2art(banner_text, font=banner_font, chr_ignore=True)
+        print(banner)
+
+    @staticmethod
+    def get_color_string(color: Optional[Dict]) -> str:
+        """Gets the color string based on the provided color settings.
+
+        Args:
+            color (Optional[Dict]): The color settings.
+
+        Returns:
+            str: The color string.
+        """
+        if color:
+            text_color = getattr(TextColors, color.get('text', 'WHITE').upper())
+            background_color = getattr(BackgroundColors, color.get('background', 'BLACK').upper())
+            return f"{text_color}{background_color}"
+        return ""

{pymenu_cli-1.0.6 → pymenu-cli-1.0.7}/pymenu_cli/models/menu_item.py

@@ -1,8 +1,11 @@
+""" This module defines the MenuItem class, which represents an item in a menu. """
+
 from typing import Optional
 
 
 class MenuItem:
-    """Represents an item in a menu.
+    """
+    Represents an item in a menu.
 
     Attributes:
         __m_title (str): The title of the menu item.
@@ -16,7 +19,8 @@ class MenuItem:
             i_title: str,
             i_action: Optional[str] = None,
             i_submenu: Optional['Menu'] = None,
-            i_color: Optional[dict] = None):
+            i_color: Optional[dict] = None
+    ):
         """
         Args:
             i_title (str): The title of the menu item.
@@ -31,18 +35,40 @@ class MenuItem:
 
     @property
     def title(self) -> str:
+        """
+        Gets the title of the menu item.
+
+        Returns:
+            str: The title of the menu item.
+        """
         return self.__m_title
 
     @property
     def color(self) -> Optional[dict]:
+        """
+        Gets the color settings of the menu item.
+
+        Returns:
+            Optional[dict]: The color settings of the menu item.
+        """
         return self.__m_color
 
     @property
     def action(self) -> Optional[str]:
+        """
+        Gets the action associated with the menu item.
+
+        Returns:
+            Optional[str]: The action associated with the menu item.
+        """
         return self.__m_action
 
     @property
     def submenu(self) -> Optional['Menu']:
-        return self.__m_submenu
-
+        """
+        Gets the submenu associated with the menu item.
 
+        Returns:
+            Optional['Menu']: The submenu associated with the menu item.
+        """
+        return self.__m_submenu

{pymenu_cli-1.0.6 → pymenu-cli-1.0.7}/pymenu_cli/pymenu.py

@@ -1,12 +1,26 @@
+"""
+This module provides functionality to load and display menus from JSON files,
+and to associate actions defined in a Python module with the menu items.
+"""
+
+import sys
+import os
+
 import argparse
 import importlib.util
 import json
+from typing import Dict
+
+# Add the project root directory to the PYTHONPATH
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
 from pymenu_cli.models.menu import Menu
 from pymenu_cli.models.menu_item import MenuItem
 
 
 def load_menu(file_path: str, actions_path: str) -> Menu:
-    """Loads a menu from a JSON file.
+    """
+    Loads a menu from a JSON file.
 
     Args:
         file_path (str): The path to the JSON file.
@@ -21,23 +35,24 @@ def load_menu(file_path: str, actions_path: str) -> Menu:
         FileNotFoundError: If the actions Python file is not found.
     """
     try:
-        with open(file_path, 'r') as file:
+        with open(file_path, 'r', encoding='utf-8') as file:
             menu_data = json.load(file)
-    except FileNotFoundError:
-        raise FileNotFoundError(f"Menu JSON file not found: {file_path}")
-    except json.JSONDecodeError as e:
-        raise json.JSONDecodeError(f"Invalid JSON format in menu file: {e}", e.doc, e.pos)
+    except FileNotFoundError as exc:
+        raise FileNotFoundError(f"Menu JSON file not found: {file_path}") from exc
+    except json.JSONDecodeError as exc:
+        raise json.JSONDecodeError(f"Invalid JSON format in menu file: {exc.msg}", exc.doc, exc.pos)
 
     try:
         actions = load_actions_module(actions_path)
-    except FileNotFoundError:
-        raise FileNotFoundError(f"Actions Python file not found: {actions_path}")
+    except FileNotFoundError as exc:
+        raise FileNotFoundError(f"Actions Python file not found: {actions_path}") from exc
 
     return create_menu_from_data(menu_data, actions)
 
 
-def create_menu_from_data(menu_data: dict, actions: object) -> Menu:
-    """Creates a menu from dictionary data.
+def create_menu_from_data(menu_data: Dict, actions: object) -> Menu:
+    """
+    Creates a menu from dictionary data.
 
     Args:
         menu_data (dict): The menu data.
@@ -46,24 +61,40 @@ def create_menu_from_data(menu_data: dict, actions: object) -> Menu:
     Returns:
         Menu: The created menu.
     """
-    menu = Menu(
-        menu_data['title'],
-        i_actions=actions,
-        i_color=menu_data.get('color'),
-        i_banner=menu_data.get('banner'))
+    config = {
+        'items': [],
+        'actions': actions,
+        'color': menu_data.get('color'),
+        'banner': menu_data.get('banner')
+    }
+
+    menu = Menu(i_title=menu_data['title'], i_config=config)
+
     for item_data in menu_data['items']:
         if 'submenu' in item_data:
             submenu = create_menu_from_data(item_data['submenu'], actions)
             menu.add_item(
-                MenuItem(item_data['title'], i_submenu=submenu, i_color=item_data.get('color')))
+                MenuItem(
+                    item_data['title'],
+                    i_submenu=submenu,
+                    i_color=item_data.get('color')
+                )
+            )
         else:
             menu.add_item(
-                MenuItem(item_data['title'], i_action=item_data.get('action'), i_color=item_data.get('color')))
+                MenuItem(
+                    item_data['title'],
+                    i_action=item_data.get('action'),
+                    i_color=item_data.get('color')
+                )
+            )
+
     return menu
 
 
 def load_actions_module(actions_path: str) -> object:
-    """Loads an actions module from a file.
+    """
+    Loads an actions module from a file.
 
     Args:
         actions_path (str): The path to the actions Python file.
@@ -82,7 +113,6 @@ def main() -> None:
     parser = argparse.ArgumentParser(description='pymenu-cli - Create interactive CLI menus')
     parser.add_argument('-m', '--menu', type=str, help='Path to the menu JSON file')
     parser.add_argument('-a', '--actions', type=str, help='Path to the actions Python file')
-
     args = parser.parse_args()
 
     if args.menu and args.actions:

{pymenu_cli-1.0.6/pymenu_cli/UI → pymenu-cli-1.0.7/pymenu_cli/ui}/styles.py

@@ -1,9 +1,17 @@
+"""
+Module for defining text and background colors as well as text styles
+using the colorama library.
+"""
+
 from enum import Enum
 from colorama import Fore, Style, Back
 
 
-# Used for returning the value from an enum as a string
 class StrEnum(Enum):
+    """
+    Enum class that returns the value as a string.
+    """
+
     def __str__(self):
         return self.value
 
@@ -12,6 +20,9 @@ class StrEnum(Enum):
 
 
 class TextColors(StrEnum):
+    """
+    Enum for defining text colors using colorama's Fore class.
+    """
     RED = Fore.RED
     LIGHT_RED = Fore.LIGHTRED_EX
     BLUE = Fore.BLUE
@@ -31,6 +42,9 @@ class TextColors(StrEnum):
 
 
 class BackgroundColors(StrEnum):
+    """
+    Enum for defining background colors using colorama's Back class.
+    """
     RED = Back.RED
     LIGHT_RED = Back.LIGHTRED_EX
     BLUE = Back.BLUE
@@ -50,9 +64,13 @@ class BackgroundColors(StrEnum):
 
 
 class Styles(StrEnum):
+    """
+    Enum for defining text styles using colorama's Style class.
+    """
     BRIGHT = Style.BRIGHT
     NORMAL = Style.NORMAL
     DIM = Style.DIM
     RESET_ALL = Style.RESET_ALL
 
-# print(f"{BackgroundColors.WHITE}{TextColors.BLACK}sdfsdfsdfsdf{Styles.RESET_ALL}")
+# Example usage:
+# print(f"{BackgroundColors.WHITE}{TextColors.BLACK}test_text{Styles.RESET_ALL}")

{pymenu_cli-1.0.6 → pymenu-cli-1.0.7}/pymenu_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymenu-cli
-Version: 1.0.6
+Version: 1.0.7
 Summary: A Python library for creating interactive CLI menus
 Home-page: https://github.com/moraneus/pymenu-cli
 Author: Moraneus
@@ -18,6 +18,13 @@ Requires-Dist: art
 
 pymenu-cli is a Python library that simplifies the creation of interactive command-line interface (CLI) menus. It provides a convenient way to define hierarchical menu structures and associate actions with menu items.
 
+<video width="320" height="240" autoplay loop muted>
+  <source src="docs/example.mp4" type="video/mp4">
+  Your browser does not support the video tag.
+</video>
+
+
+
 ## Features
 
 - Define menus and submenus using a simple JSON file format
@@ -42,8 +49,9 @@ pip install pymenu-cli
 2. Implement the corresponding action functions in a separate Python file (`actions.py`)
 
 ### Using the Python API
+
 ```python
-from pymenu_cli.pymenu import load_menu
+from pymenu_cli.menu import load_menu
 
 # Define the 'menu' and the 'action' files 
 menu_file_path = 'menu.json'
@@ -275,3 +283,77 @@ python3 menu_example.py
 
 ### License
 This project is licensed under the MIT License.
+
+## Contributors
+# Contributing to pymenu-cli
+
+Thank you for considering contributing to pymenu-cli! We welcome all contributions, whether they are bug reports, feature requests, or code improvements. Please take a moment to review this document before submitting your contributions.
+
+## How to Contribute
+
+### Reporting Bugs
+
+If you find a bug, please report it by [opening an issue](https://github.com/moraneus/pymenu-cli/issues). Include as much detail as possible to help us reproduce and fix the issue quickly. Make sure to include:
+
+- A clear and descriptive title.
+- A detailed description of the problem.
+- Steps to reproduce the issue.
+- Any relevant logs or screenshots.
+
+### Suggesting Enhancements
+
+We welcome suggestions for new features and enhancements. To suggest an enhancement, please [open an issue](https://github.com/moraneus/pymenu-cli/issues) and provide:
+
+- A clear and descriptive title.
+- A detailed description of the proposed enhancement.
+- Any relevant examples or mockups.
+
+### Submitting Pull Requests
+
+To submit a pull request (PR), follow these steps:
+
+1. **Fork the repository**: Click the "Fork" button at the top of this page to create a copy of the repository on your GitHub account.
+
+2. **Clone your fork**: Clone the forked repository to your local machine using the following command:
+    ```bash
+    git clone https://github.com/moraneus/pymenu-cli.git
+    cd pymenu-cli
+    ```
+
+3. **Create a new branch**: Create a new branch for your work. Use a descriptive name for the branch:
+    ```bash
+    git checkout -b feature/my-new-feature
+    ```
+
+4. **Make your changes**: Make your changes in the new branch.
+
+5. **Commit your changes**: Commit your changes with a clear and concise commit message:
+    ```bash
+    git add .
+    git commit -m "Add feature: my new feature"
+    ```
+
+6. **Push to your fork**: Push your changes to your forked repository:
+    ```bash
+    git push origin feature/my-new-feature
+    ```
+
+7. **Open a pull request**: Go to the original repository and open a pull request from your forked repository. Provide a clear and descriptive title and description for your PR.
+
+### Code Style and Guidelines
+
+- Follow the existing code style and conventions.
+- Write clear and concise commit messages.
+- Write tests for new features and bug fixes.
+- Ensure your code passes all existing tests.
+
+### Running Tests
+
+Before submitting your PR, make sure all tests pass. You can run the tests using the following commands:
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run tests
+pytest

{pymenu_cli-1.0.6 → pymenu-cli-1.0.7}/pymenu_cli.egg-info/SOURCES.txt

@@ -8,8 +8,12 @@ pymenu_cli.egg-info/dependency_links.txt
 pymenu_cli.egg-info/entry_points.txt
 pymenu_cli.egg-info/requires.txt
 pymenu_cli.egg-info/top_level.txt
-pymenu_cli/UI/__init__.py
-pymenu_cli/UI/styles.py
 pymenu_cli/models/__init__.py
 pymenu_cli/models/menu.py
-pymenu_cli/models/menu_item.py
+pymenu_cli/models/menu_item.py
+pymenu_cli/ui/__init__.py
+pymenu_cli/ui/styles.py
+tests/__init__.py
+tests/test_menu.py
+tests/test_menu_item.py
+tests/test_pymenu.py

{pymenu_cli-1.0.6 → pymenu-cli-1.0.7}/pymenu_cli.egg-info/top_level.txt

@@ -1 +1,2 @@
 pymenu_cli
+tests

{pymenu_cli-1.0.6 → pymenu-cli-1.0.7}/setup.py

@@ -1,12 +1,19 @@
-import colorama
+"""Module for setting up the pymenu-cli package."""
+
 from setuptools import setup, find_packages
 
+# Read the contents of the README and CONTRIBUTORS files
 with open("README.md", "r", encoding="utf-8") as fh:
-    long_description = fh.read()
+    readme = fh.read()
+
+with open("CONTRIBUTING.md", "r", encoding="utf-8") as fh:
+    contributing = fh.read()
+
+long_description = f"{readme}\n\n## Contributors\n{contributing}"
 
 setup(
     name='pymenu-cli',
-    version='1.0.6',
+    version='1.0.7',
     description='A Python library for creating interactive CLI menus',
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -24,4 +31,4 @@ setup(
         ]
     },
     license='MIT',
-)
+)

pymenu-cli-1.0.7/tests/test_menu.py

@@ -0,0 +1,106 @@
+import pytest
+from unittest.mock import patch, Mock
+
+from pymenu_cli.models.menu import Menu
+from pymenu_cli.models.menu_item import MenuItem
+
+
+# Tests for the Menu class
+def test_menu_init():
+    """
+    Test that the Menu instance is correctly initialized with the
+    provided title and configuration.
+    """
+    title = "Main Menu"
+    config = {
+        "items": [],
+        "actions": Mock(),
+        "color": {"text": "red", "background": "blue"},
+        "banner": {"title": "Banner", "font": "standard"},
+    }
+
+    menu = Menu(title, i_config=config)
+
+    assert menu.title == title
+    assert menu.items == config["items"]
+    assert menu.actions == config["actions"]
+    assert menu.color == config["color"]
+    assert menu.banner == config["banner"]
+
+
+def test_menu_add_item():
+    """
+    Test that the add_item method of the Menu class correctly adds
+    a new MenuItem to the menu.
+    """
+    menu = Menu("Test Menu")
+    item = MenuItem("Item 1")
+
+    menu.add_item(item)
+
+    assert len(menu.items) == 1
+    assert menu.items[0] == item
+
+
+def test_menu_display(capsys, monkeypatch):
+    """
+    Test that the display method of the Menu class correctly displays
+    the menu and handles user input.
+    """
+    actions = Mock()  # Create a Mock object for actions
+
+    menu = Menu("Test Menu", i_config={"actions": actions})
+    item1 = MenuItem("Item 1", i_action="action1")
+    item2 = MenuItem("Item 2", i_submenu=Menu("Submenu"))
+    menu.add_item(item1)
+    menu.add_item(item2)
+
+    # Mock the user input
+    user_inputs = iter(["1", "2", "B"])
+    monkeypatch.setattr("builtins.input", lambda _: next(user_inputs))
+
+    # Mock the actions and submenu.display methods
+    mock_action1 = Mock()
+    mock_submenu_display = Mock()
+    actions.action1 = mock_action1  # Assign the Mock to actions.action1
+    menu.items[1].submenu.display = mock_submenu_display
+
+    # Call the display method
+    menu.display()
+
+    # Assert that the actions and submenu.display methods were called
+    mock_action1.assert_called_once()
+    mock_submenu_display.assert_called_once()
+
+
+def test_menu_get_color_string():
+    """
+    Test that the get_color_string method of the Menu class
+    correctly returns the color string based on the provided color settings.
+    """
+    # Test with valid color settings
+    color = {"text": "red", "background": "blue"}
+    expected_color_string = "\x1b[31m\x1b[44m"
+    assert Menu.get_color_string(color) == expected_color_string
+
+    # Test with invalid color settings
+    color = {"text": "invalid", "background": "invalid"}
+    with pytest.raises(AttributeError):
+        Menu.get_color_string(color)
+
+    # Test with no color settings
+    assert Menu.get_color_string(None) == ""
+
+
+def test_menu_print_banner(capsys):
+    """
+    Test that the print_banner method of the Menu class
+    correctly prints the banner using the art library.
+    """
+    menu = Menu("Test Menu", i_config={"banner": {"title": "Banner Text", "font": "standard"}})
+
+    # Mock the art.text2art function
+    with patch("art.text2art", return_value="ASCII_ART"):
+        menu.print_banner()
+        captured = capsys.readouterr()
+        assert captured.out == "ASCII_ART\n"

pymenu-cli-1.0.7/tests/test_menu_item.py

@@ -0,0 +1,75 @@
+from pymenu_cli.models.menu_item import MenuItem
+from pymenu_cli.models.menu import Menu
+
+
+# Tests for the MenuItem class
+def test_menu_item_init():
+    """
+    Test that the MenuItem instance is correctly initialized with the
+    provided title, action, submenu, and color settings.
+    """
+    title = "Menu Item"
+    action = "action_name"
+    submenu = Menu("Submenu")
+    color = {"text": "green", "background": "black"}
+
+    item = MenuItem(title, action, submenu, color)
+
+    assert item.title == title
+    assert item.action == action
+    assert item.submenu == submenu
+    assert item.color == color
+
+
+def test_menu_item_properties():
+    """
+    Test that the properties of the MenuItem class
+    return the correct values.
+    """
+    title = "Menu Item"
+    action = "action_name"
+    submenu = Menu("Submenu")
+    color = {"text": "green", "background": "black"}
+
+    item = MenuItem(title, action, submenu, color)
+
+    assert item.title == title
+    assert item.action == action
+    assert item.submenu == submenu
+    assert item.color == color
+
+
+def test_menu_item_with_optional_args():
+    """
+    Test that the MenuItem instance is correctly initialized
+    when some arguments are not provided.
+    """
+    title = "Menu Item"
+
+    # No action, submenu, or color
+    item = MenuItem(title)
+    assert item.title == title
+    assert item.action is None
+    assert item.submenu is None
+    assert item.color is None
+
+    # Only action
+    item = MenuItem(title, i_action="action_name")
+    assert item.title == title
+    assert item.action == "action_name"
+    assert item.submenu is None
+    assert item.color is None
+
+    # Only submenu
+    item = MenuItem(title, i_submenu=Menu("Submenu"))
+    assert item.title == title
+    assert item.action is None
+    assert isinstance(item.submenu, Menu)
+    assert item.color is None
+
+    # Only color
+    item = MenuItem(title, i_color={"text": "red"})
+    assert item.title == title
+    assert item.action is None
+    assert item.submenu is None
+    assert item.color == {"text": "red"}

pymenu-cli-1.0.7/tests/test_pymenu.py

@@ -0,0 +1,153 @@
+import json
+import pytest
+from unittest.mock import Mock, patch
+
+from pymenu_cli.pymenu import load_menu, create_menu_from_data, load_actions_module, main
+from pymenu_cli.models.menu import Menu
+
+
+# Tests for load_menu function
+def test_load_menu_with_valid_paths(tmp_path):
+    """
+    Test that the load_menu function correctly loads a menu from a JSON file
+    and associates actions from a Python module when provided with valid file paths.
+    """
+    # Create temporary files
+    menu_file = tmp_path / "menu.json"
+    actions_file = tmp_path / "actions.py"
+
+    # Write sample data to the temporary files
+    menu_data = {"title": "Main Menu", "items": [{"title": "Item 1"}, {"title": "Item 2"}]}
+    with open(menu_file, "w", encoding="utf-8") as f:
+        json.dump(menu_data, f)
+
+    with open(actions_file, "w", encoding="utf-8") as f:
+        f.write("def action1(): pass\ndef action2(): pass")
+
+    # Call the load_menu function
+    menu = load_menu(str(menu_file), str(actions_file))
+
+    # Assert that the menu and its items were loaded correctly
+    assert isinstance(menu, Menu)
+    assert menu.title == "Main Menu"
+    assert len(menu.items) == 2
+    assert menu.items[0].title == "Item 1"
+    assert menu.items[1].title == "Item 2"
+
+
+def test_load_menu_with_missing_files():
+    """
+    Test that the load_menu function raises a FileNotFoundError when the
+    provided file paths are invalid or the files are missing.
+    """
+    with pytest.raises(FileNotFoundError):
+        load_menu("invalid_path.json", "actions.py")
+
+    with pytest.raises(FileNotFoundError):
+        load_menu("menu.json", "invalid_path.py")
+
+
+# Tests for create_menu_from_data function
+def test_create_menu_from_data():
+    """
+    Test that the create_menu_from_data function correctly creates a Menu object
+    and its associated MenuItem objects from a dictionary of menu data.
+    """
+    menu_data = {
+        "title": "Main Menu",
+        "items": [
+            {"title": "Item 1", "action": "action1"},
+            {"title": "Item 2", "submenu": {"title": "Submenu", "items": [{"title": "Subitem 1"}]}},
+        ],
+    }
+    actions = Mock()
+    actions.action1 = Mock()
+
+    menu = create_menu_from_data(menu_data, actions)
+
+    assert isinstance(menu, Menu)
+    assert menu.title == "Main Menu"
+    assert len(menu.items) == 2
+    assert menu.items[0].title == "Item 1"
+    assert menu.items[0].action == "action1"
+    assert menu.items[1].title == "Item 2"
+    assert isinstance(menu.items[1].submenu, Menu)
+    assert menu.items[1].submenu.title == "Submenu"
+    assert len(menu.items[1].submenu.items) == 1
+    assert menu.items[1].submenu.items[0].title == "Subitem 1"
+
+
+# Tests for load_actions_module function
+def test_load_actions_module(tmp_path):
+    """
+    Test that the load_actions_module function correctly loads a Python module
+    from a file and returns an object containing the module's callable functions.
+    """
+    actions_file = tmp_path / "actions.py"
+
+    with open(actions_file, "w", encoding="utf-8") as f:
+        f.write("def action1(): pass\ndef action2(): pass")
+
+    actions = load_actions_module(str(actions_file))
+
+    assert hasattr(actions, "action1")
+    assert hasattr(actions, "action2")
+
+
+def test_load_actions_module_with_missing_file():
+    """
+    Test that the load_actions_module function raises a FileNotFoundError
+    when the provided file path is invalid or the file is missing.
+    """
+    with pytest.raises(FileNotFoundError):
+        load_actions_module("invalid_path.py")
+
+
+# Tests for the main function
+def test_main_with_valid_args(tmp_path, monkeypatch, capsys):
+    """
+    Test that the main function correctly loads and displays the menu
+    when provided with valid command-line arguments.
+    """
+    # Create temporary files
+    menu_file = tmp_path / "menu.json"
+    actions_file = tmp_path / "actions.py"
+
+    # Write sample data to the temporary files
+    menu_data = {"title": "Main Menu", "items": [{"title": "Item 1"}, {"title": "Item 2"}]}
+    with open(menu_file, "w", encoding="utf-8") as f:
+        json.dump(menu_data, f)
+
+    with open(actions_file, "w", encoding="utf-8") as f:
+        f.write("def action1(): pass\ndef action2(): pass")
+
+    # Mock the display method of the Menu class
+    with patch.object(Menu, "display") as mock_display:
+        # Mock the argparse.ArgumentParser.parse_args method
+        monkeypatch.setattr("argparse.ArgumentParser.parse_args",
+                            lambda self: Mock(menu=str(menu_file), actions=str(actions_file)))
+
+        # Call the main function
+        main()
+
+        # Assert that the display method was called
+        mock_display.assert_called_once()
+
+
+def test_main_with_missing_args(capsys):
+    """
+    Test that the main function prints the help message
+    when command-line arguments are missing.
+    """
+    # Mock the argparse.ArgumentParser.parse_args method
+    with patch("argparse.ArgumentParser.parse_args", return_value=Mock(menu=None, actions=None)):
+        with patch("argparse.ArgumentParser.print_help") as mock_print_help:
+            # Call the main function
+            main()
+
+            # Assert that the print_help method was called
+            mock_print_help.assert_called_once()
+
+    # Capture the printed output
+    captured = capsys.readouterr()
+    assert captured.out == ""  # No output should be printed

pymenu_cli-1.0.6/pymenu_cli/models/menu.py

@@ -1,108 +0,0 @@
-import os
-from typing import Optional, List
-
-import art
-
-from pymenu_cli.UI.styles import Styles, TextColors, BackgroundColors
-from pymenu_cli.models.menu_item import MenuItem
-
-
-class Menu:
-    """Represents a menu.
-
-    Attributes:
-        __m_title (str): The title of the menu.
-        __m_items (List[MenuItem]): A list of items in the menu.
-        __m_actions (Optional[object]): An object containing callable actions.
-        __m_color (Optional[dict]): The color settings for the menu title.
-        __m_banner (Optional[dict]): The banner for the menu.
-    """
-
-    def __init__(
-            self,
-            i_title: str,
-            i_items: Optional[List[MenuItem]] = None,
-            i_actions: Optional[object] = None,
-            i_color: Optional[dict] = None,
-            i_banner: Optional[dict] = None):
-        """
-        Args:
-            i_title (str): The title of the menu.
-            i_items (Optional[List[MenuItem]]): A list of items in the menu. Defaults to None.
-            i_actions (Optional[object]): An object containing callable actions. Defaults to None.
-            i_color (Optional[dict]): The color settings for the menu title. Defaults to None.
-            i_banner (Optional[dict]): The banner for the menu. Defaults to None.
-        """
-        self.__m_title = i_title
-        self.__m_items = i_items or []
-        self.__m_actions = i_actions
-        self.__m_color = i_color
-        self.__m_banner = i_banner
-
-    def add_item(self, i_item: MenuItem) -> None:
-        """Adds an item to the menu.
-
-        Args:
-            i_item (MenuItem): The item to add.
-        """
-        self.__m_items.append(i_item)
-
-    def display(self) -> None:
-        """Displays the menu and handles user input."""
-        while True:
-            os.system('cls' if os.name == 'nt' else 'clear')
-
-            if self.__m_banner:
-                self.print_banner()
-
-            title_color = Menu.get_color_string(self.__m_color)
-            print(f"\n{title_color}{self.__m_title}{Styles.RESET_ALL}\n")
-
-            for i, item in enumerate(self.__m_items, start=1):
-                item_color = self.get_color_string(item.color)
-                print(f"{i}. {item_color}{item.title}{Styles.RESET_ALL}")
-
-            print("\nB. Back")
-            print("X. Exit")
-
-            choice = input("\nEnter your choice: ").upper()
-
-            if choice == 'B':
-                return
-            elif choice == 'X':
-                exit()
-            else:
-                try:
-                    index = int(choice) - 1
-                    if 0 <= index < len(self.__m_items):
-                        selected_item = self.__m_items[index]
-                        if selected_item.submenu:
-                            selected_item.submenu.display()
-                        elif selected_item.action:
-                            getattr(self.__m_actions, selected_item.action)()
-                    else:
-                        raise ValueError
-                except (ValueError, IndexError):
-                    input("\nInvalid choice. Press Enter to try again.")
-
-    def print_banner(self) -> None:
-        banner_text = self.__m_banner.get('title', '')
-        banner_font = self.__m_banner.get('font', 'standard')
-        banner = art.text2art(banner_text, font=banner_font, chr_ignore=True)
-        print(banner)
-
-    @staticmethod
-    def get_color_string(i_color: Optional[dict]) -> str:
-        """Gets the color string based on the provided color settings.
-
-        Args:
-            i_color (Optional[dict]): The color settings.
-
-        Returns:
-            str: The color string.
-        """
-        if i_color:
-            text_color = getattr(TextColors, i_color.get('text', 'WHITE').upper())
-            background_color = getattr(BackgroundColors, i_color.get('background', 'BLACK').upper())
-            return f"{text_color}{background_color}"
-        return ""