exonware-xwsystem 0.1.0.1__py3-none-any.whl → 0.1.0.3__py3-none-any.whl

exonware/xwsystem/{cli → console/cli}/args.py

@@ -1,3 +1,4 @@
+#exonware/xwsystem/src/exonware/xwsystem/console/cli/args.py
 """
 Argument Parsing Utilities
 =========================
@@ -7,13 +8,15 @@ Production-grade CLI argument parsing for XWSystem.
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.1.0.1
+Version: 0.1.0.3
 Generated: 2025-01-27
 """
 
+from __future__ import annotations
+
 import argparse
 import sys
-from typing import Any, Optional, Callable, Union
+from typing import Any, Optional, Callable
 from dataclasses import dataclass
 import logging
 from .defs import ArgumentType
@@ -22,7 +25,7 @@ logger = logging.getLogger(__name__)
 
 
 @dataclass
-class Argument:
+class CliArgument:
     """
     Definition of a command-line argument.
     
@@ -43,7 +46,7 @@ class Argument:
     choices: Optional[list[str]] = None
     validator: Optional[Callable[[Any], bool]] = None
     action: str = "store"  # store, store_true, store_false, append, count
-    nargs: Optional[Union[int, str]] = None  # Number of arguments
+    nargs: Optional[int | str] = None  # Number of arguments
     
     def __post_init__(self):
         """Validate argument configuration."""
@@ -58,7 +61,7 @@ class Argument:
 
 
 @dataclass 
-class Command:
+class CliCommand:
     """
     Definition of a CLI command.
     
@@ -72,8 +75,8 @@ class Command:
     name: str
     handler: Callable
     description: str = ""
-    arguments: list[Argument] = None
-    subcommands: list['Command'] = None
+    arguments: list[CliArgument] = None
+    subcommands: list[CliCommand] = None
     examples: list[str] = None
     
     def __post_init__(self):
@@ -86,7 +89,7 @@ class Command:
             self.examples = []
 
 
-class ArgumentParser:
+class CliArgumentParser:
     """
     Production-grade argument parser built on argparse.
     
@@ -134,11 +137,11 @@ class ArgumentParser:
             )
         
         # Command registry
-        self._commands: dict[str, Command] = {}
+        self._commands: dict[str, CliCommand] = {}
         self._subparsers = None
-        self._global_arguments: list[Argument] = []
+        self._global_arguments: list[CliArgument] = []
     
-    def add_argument(self, argument: Argument) -> 'ArgumentParser':
+    def add_argument(self, argument: CliArgument) -> CliArgumentParser:
         """
         Add a global argument to the parser.
         
@@ -152,7 +155,7 @@ class ArgumentParser:
         self._add_argument_to_parser(self._parser, argument)
         return self
     
-    def add_command(self, command: Command) -> 'ArgumentParser':
+    def add_command(self, command: CliCommand) -> CliArgumentParser:
         """
         Add a command to the parser.
         
@@ -201,7 +204,7 @@ class ArgumentParser:
         
         return self
     
-    def _add_subcommand(self, subparsers, command: Command, parent_name: str):
+    def _add_subcommand(self, subparsers, command: CliCommand, parent_name: str):
         """Add a subcommand to a subparser."""
         subcmd_parser = subparsers.add_parser(
             command.name,
@@ -216,7 +219,7 @@ class ArgumentParser:
         full_name = f"{parent_name}.{command.name}"
         self._commands[full_name] = command
     
-    def _add_argument_to_parser(self, parser: argparse.ArgumentParser, argument: Argument):
+    def _add_argument_to_parser(self, parser: argparse.ArgumentParser, argument: CliArgument):
         """Add an argument to an argparse parser."""
         kwargs = {
             'help': argument.help_text,
@@ -340,9 +343,9 @@ class ArgumentParser:
 
 
 # Utility functions for common argument types
-def create_file_argument(name: str, required: bool = False, help_text: str = "") -> Argument:
+def create_file_argument(name: str, required: bool = False, help_text: str = "") -> CliArgument:
     """Create a file input argument."""
-    return Argument(
+    return CliArgument(
         name=name,
         arg_type=ArgumentType.FILE,
         required=required,
@@ -350,18 +353,18 @@ def create_file_argument(name: str, required: bool = False, help_text: str = "")
     )
 
 
-def create_output_argument(name: str = "output", help_text: str = "") -> Argument:
+def create_output_argument(name: str = "output", help_text: str = "") -> CliArgument:
     """Create an output file argument."""
-    return Argument(
+    return CliArgument(
         name=name,
         arg_type=ArgumentType.STRING,
         help_text=help_text or "Output file path"
     )
 
 
-def create_verbose_argument() -> Argument:
+def create_verbose_argument() -> CliArgument:
     """Create a verbose flag argument."""
-    return Argument(
+    return CliArgument(
         name="verbose",
         short_name="-v",
         action="store_true",
@@ -369,9 +372,9 @@ def create_verbose_argument() -> Argument:
     )
 
 
-def create_quiet_argument() -> Argument:
+def create_quiet_argument() -> CliArgument:
     """Create a quiet flag argument."""
-    return Argument(
+    return CliArgument(
         name="quiet",
         short_name="-q", 
         action="store_true",
@@ -379,9 +382,9 @@ def create_quiet_argument() -> Argument:
     )
 
 
-def create_config_argument() -> Argument:
+def create_config_argument() -> CliArgument:
     """Create a configuration file argument."""
-    return Argument(
+    return CliArgument(
         name="config",
         short_name="-c",
         arg_type=ArgumentType.FILE,

exonware/xwsystem/{cli → console/cli}/base.py

@@ -1,50 +1,41 @@
+#exonware/xwsystem/src/exonware/xwsystem/console/cli/base.py
 #exonware/xwsystem/cli/base.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.1.0.1
+Version: 0.1.0.3
 Generation Date: September 04, 2025
 
 CLI module base classes - abstract classes for command-line interface functionality.
 """
 
 from abc import ABC, abstractmethod
-from typing import Any, Optional, Union
+from typing import Any, Optional
 from .contracts import ColorType, ProgressStyle, TableStyle, PromptType, ICLI
-from ..version import __version__
+from ..base import AConsoleWriter
+from exonware.xwsystem.version import __version__
 
 
-class AConsoleBase(ABC):
-    """Abstract base class for console operations."""
+class AConsoleBase(AConsoleWriter):
+    """
+    Abstract base class for console operations (CLI-specific).
     
-    @abstractmethod
-    def print(self, text: str, color: Optional[ColorType] = None, **kwargs) -> None:
-        """Print text to console."""
-        pass
+    Extends AConsoleWriter from console level to add CLI-specific methods.
+    """
     
     @abstractmethod
-    def input(self, prompt: str, **kwargs) -> str:
-        """Get input from user."""
-        pass
-    
-    @abstractmethod
-    def clear(self) -> None:
-        """Clear console screen."""
+    def print(self, text: str, color: Optional[ColorType] = None, **kwargs) -> None:
+        """Print text to console with optional color."""
         pass
     
     @abstractmethod
     def get_size(self) -> tuple[int, int]:
         """Get console size."""
         pass
-    
-    @abstractmethod
-    def is_interactive(self) -> bool:
-        """Check if console is interactive."""
-        pass
 
 
-class AProgressBarBase(ABC):
+class CliAProgressBarBase(ABC):
     """Abstract base class for progress bar operations."""
     
     def __init__(self, total: int, description: str = "", style: ProgressStyle = ProgressStyle.BAR):
@@ -82,7 +73,7 @@ class AProgressBarBase(ABC):
         pass
 
 
-class ATableBase(ABC):
+class CliATableBase(ABC):
     """Abstract base class for table operations."""
     
     def __init__(self, headers: list[str], style: TableStyle = TableStyle.SIMPLE):
@@ -118,7 +109,7 @@ class ATableBase(ABC):
         pass
 
 
-class APromptBase(ABC):
+class CliAPromptBase(ABC):
     """Abstract base class for user prompts."""
     
     @abstractmethod
@@ -142,7 +133,7 @@ class APromptBase(ABC):
         pass
 
 
-class AArgumentParserBase(ABC):
+class CliAArgumentParserBase(ABC):
     """Abstract base class for argument parsing."""
     
     def __init__(self, description: str = ""):
@@ -176,7 +167,7 @@ class AArgumentParserBase(ABC):
         pass
 
 
-class AColorBase(ABC):
+class CliAColorBase(ABC):
     """Abstract base class for color operations."""
     
     @abstractmethod
@@ -195,69 +186,9 @@ class AColorBase(ABC):
         pass
 
 
-class BaseCLI(ICLI):
+class CliBase(ICLI):
     """Base CLI implementation."""
     
-    def __init__(self, name: str = "xwsystem", version: str = None):
-        """Initialize the CLI.
-        
-        Args:
-            name: CLI name
-            version: CLI version (defaults to package version)
-        """
-        self._name = name
-        self._version = version or __version__
-        self._commands: dict[str, Any] = {}
-        self._options: dict[str, Any] = {}
-    
-    @property
-    def name(self) -> str:
-        """Get CLI name."""
-        return self._name
-    
-    @property
-    def version(self) -> str:
-        """Get CLI version."""
-        return self._version
-    
-    def add_command(self, name: str, command: Any) -> None:
-        """Add a command to the CLI.
-        
-        Args:
-            name: Command name
-            command: Command implementation
-        """
-        self._commands[name] = command
-    
-    def add_option(self, name: str, option: Any) -> None:
-        """Add an option to the CLI.
-        
-        Args:
-            name: Option name
-            option: Option implementation
-        """
-        self._options[name] = option
-    
-    def run(self, args: Optional[list[str]] = None) -> int:
-        """Run the CLI.
-        
-        Args:
-            args: Command line arguments
-            
-        Returns:
-            Exit code
-        """
-        # Basic implementation - can be overridden
-        return 0
-    
-    def get_help(self) -> str:
-        """Get help text."""
-        return f"{self._name} v{self._version} - XWSystem CLI"
-
-
-class BaseCLI(ICLI):
-    """Base CLI implementation for backward compatibility."""
-    
     def __init__(self, name: str = "xwsystem", version: str = None):
         """Initialize base CLI."""
         self._name = name

exonware/xwsystem/{cli → console/cli}/colors.py

@@ -1,8 +1,9 @@
+#exonware/xwsystem/src/exonware/xwsystem/console/cli/colors.py
 """
 Company: eXonware.com
 Author: Eng. Muhammad AlShehri
 Email: connect@exonware.com
-Version: 0.1.0.1
+Version: 0.1.0.3
 Generation Date: September 05, 2025
 
 Colored terminal output utilities with cross-platform support.
@@ -10,8 +11,9 @@ Colored terminal output utilities with cross-platform support.
 
 import os
 import sys
-from typing import Optional, Union
-from .defs import Colors, Style
+from typing import Optional
+# Import general console enums from console level (priority)
+from ..defs import Colors, Style
 
 # Explicit import - colorama is a required dependency for CLI functionality
 # This ensures consistent cross-platform colored output
@@ -19,12 +21,12 @@ from .defs import Colors, Style
 import colorama
 colorama.init(autoreset=True)
 
-from ..config.logging_setup import get_logger
+from ...config.logging_setup import get_logger
 
 logger = get_logger("xwsystem.cli.colors")
 
 
-class ColoredOutput:
+class CliColoredOutput:
     """
     Cross-platform colored terminal output.
     
@@ -73,7 +75,7 @@ class ColoredOutput:
         if 'color' in term or term in ('xterm', 'xterm-256color', 'screen', 'tmux'):
             return True
         
-        # Lazy installation ensures colorama is always available
+        # Lazy installation provides colorama when available
         # Works on all platforms
         return True
     
@@ -81,7 +83,7 @@ class ColoredOutput:
         """Check if colored output is supported."""
         return self._supports_color
     
-    def colorize(self, text: str, color: Union[Colors, str], style: Optional[Union[Style, str]] = None) -> str:
+    def colorize(self, text: str, color: Colors | str, style: Optional[Style | str] = None) -> str:
         """
         Apply color and style to text.
         
@@ -114,8 +116,8 @@ class ColoredOutput:
         else:
             return f"{color_str}{text}"
     
-    def print_colored(self, text: str, color: Union[Colors, str], 
-                     style: Optional[Union[Style, str]] = None, **kwargs) -> None:
+    def print_colored(self, text: str, color: Colors | str, 
+                     style: Optional[Style | str] = None, **kwargs) -> None:
         """
         Print colored text.
         
@@ -228,15 +230,15 @@ class ColoredOutput:
 
 
 # Global colored output instance
-_colored_output = ColoredOutput()
+_colored_output = CliColoredOutput()
 
 # Convenience functions
-def colorize(text: str, color: Union[Colors, str], style: Optional[Union[Style, str]] = None) -> str:
+def colorize(text: str, color: Colors | str, style: Optional[Style | str] = None) -> str:
     """Colorize text using global instance."""
     return _colored_output.colorize(text, color, style)
 
-def print_colored(text: str, color: Union[Colors, str], 
-                 style: Optional[Union[Style, str]] = None, **kwargs) -> None:
+def print_colored(text: str, color: Colors | str, 
+                 style: Optional[Style | str] = None, **kwargs) -> None:
     """Print colored text using global instance."""
     _colored_output.print_colored(text, color, style, **kwargs)
 

exonware/xwsystem/console/cli/console.py

@@ -0,0 +1,98 @@
+#exonware/xwsystem/src/exonware/xwsystem/console/cli/console.py
+"""
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.3
+Generation Date: September 04, 2025
+
+Console utilities for CLI operations.
+"""
+
+import os
+from typing import Optional
+from .contracts import IConsole, ColorType
+from .errors import ConsoleError
+# Import ConsoleWriter from console level (priority)
+from ..writer import ConsoleWriter
+
+
+class CliConsole(ConsoleWriter, IConsole):
+    """
+    Console implementation for CLI operations.
+    
+    Extends ConsoleWriter from console level and adds CLI-specific features
+    like color support and IConsole interface compliance.
+    """
+    
+    def print(self, text: str, color: Optional[ColorType] = None, **kwargs) -> None:
+        """
+        Print text to console with optional color.
+        
+        Args:
+            text: Text to print
+            color: Optional color type to apply
+            **kwargs: Additional arguments passed to print()
+        """
+        try:
+            if color and self.supports_color():
+                text = self._apply_color(text, color)
+            
+            # Use parent's write_line method
+            self.write_line(text, **kwargs)
+        except Exception as e:
+            raise ConsoleError(f"Failed to print to console: {e}")
+    
+    def input(self, prompt: str, **kwargs) -> str:
+        """
+        Get input from user.
+        
+        Args:
+            prompt: Prompt text
+            **kwargs: Additional arguments (for compatibility)
+            
+        Returns:
+            User input string
+        """
+        try:
+            # Use parent's read method
+            return self.read(prompt)
+        except Exception as e:
+            raise ConsoleError(f"Failed to get input: {e}")
+    
+    def _apply_color(self, text: str, color: ColorType) -> str:
+        """Apply color to text."""
+        color_codes = {
+            ColorType.RESET: '\033[0m',
+            ColorType.BOLD: '\033[1m',
+            ColorType.DIM: '\033[2m',
+            ColorType.UNDERLINE: '\033[4m',
+            ColorType.RED: '\033[31m',
+            ColorType.GREEN: '\033[32m',
+            ColorType.YELLOW: '\033[33m',
+            ColorType.BLUE: '\033[34m',
+            ColorType.MAGENTA: '\033[35m',
+            ColorType.CYAN: '\033[36m',
+            ColorType.WHITE: '\033[37m',
+            ColorType.GRAY: '\033[90m',
+        }
+        
+        code = color_codes.get(color, '')
+        return f"{code}{text}\033[0m" if code else text
+    
+    def get_size(self) -> tuple[int, int]:
+        """
+        Get console size.
+        
+        Returns:
+            Tuple of (columns, lines)
+        """
+        try:
+            if hasattr(os, 'get_terminal_size'):
+                size = os.get_terminal_size()
+                return (size.columns, size.lines)
+            else:
+                return (80, 24)  # Default size
+        except (OSError, AttributeError, RuntimeError):
+            # Catch specific exceptions - terminal size may not be available
+            return (80, 24)