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

exonware/xwsystem/config/version_manager.py

@@ -1,3 +1,4 @@
+#exonware/xwsystem/src/exonware/xwsystem/config/version_manager.py
 """
 Centralized version management for eXonware projects.
 

exonware/xwsystem/config.py

@@ -0,0 +1,27 @@
+"""
+#exonware/xwsystem/src/exonware/xwsystem/config.py
+
+Package-level configuration entry points for xwsystem.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.3
+Last Updated: 29-Jan-2026
+
+This module exists to satisfy the canonical structure in GUIDE_31_DEV.md:
+- `config.py` at package root for configuration surfaces.
+
+The concrete configuration system lives under `exonware.xwsystem.config`.
+"""
+
+from __future__ import annotations
+
+from .config.logging_setup import get_logger, setup_logging
+
+
+__all__ = [
+    "get_logger",
+    "setup_logging",
+]
+

exonware/xwsystem/console/__init__.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+#exonware/xwsystem/src/exonware/xwsystem/console/__init__.py
+#exonware/xwsystem/console/__init__.py
+"""
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.3
+Generation Date: 2025-01-27
+
+Console module for structured logging and user interaction.
+"""
+
+from .defs import (
+    LogLevel,
+    ConsoleEventType,
+    ConsoleEvent,
+)
+from .contracts import (
+    IEventLogger,
+    IConsoleWriter,
+)
+from .base import (
+    AEventLogger,
+    AConsoleWriter,
+)
+from .event_logger import ConsoleEventLogger
+from .writer import ConsoleWriter
+from .errors import (
+    ConsoleError,
+    EventLoggerError,
+    ConsoleWriterError,
+)
+
+__all__ = [
+    # Type definitions
+    'LogLevel',
+    'ConsoleEventType',
+    'ConsoleEvent',
+    # Interfaces
+    'IEventLogger',
+    'IConsoleWriter',
+    # Abstract base classes
+    'AEventLogger',
+    'AConsoleWriter',
+    # Implementations
+    'ConsoleEventLogger',
+    'ConsoleWriter',
+    # Errors
+    'ConsoleError',
+    'EventLoggerError',
+    'ConsoleWriterError',
+]

exonware/xwsystem/console/base.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+#exonware/xwsystem/src/exonware/xwsystem/console/base.py
+#exonware/xwsystem/console/base.py
+"""
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.3
+Generation Date: 2025-01-27
+
+Console module base classes - abstract base classes for console functionality.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, Any
+from .contracts import IEventLogger, IConsoleWriter
+from .defs import LogLevel, ConsoleEventType, ConsoleEvent
+
+
+class AEventLogger(ABC, IEventLogger):
+    """
+    Abstract base class for event logging.
+    
+    All event loggers should extend this class.
+    """
+    
+    @abstractmethod
+    def log(
+        self,
+        msg: str,
+        source: Optional[str] = None,
+        data: Optional[Any] = None,
+        color: Optional[str] = None,
+        label: Optional[str] = None
+    ) -> ConsoleEvent:
+        """Log a general message."""
+        pass
+    
+    @abstractmethod
+    def info(
+        self,
+        msg: str,
+        source: Optional[str] = None,
+        data: Optional[Any] = None
+    ) -> ConsoleEvent:
+        """Log an info message."""
+        pass
+    
+    @abstractmethod
+    def warn(
+        self,
+        msg: str,
+        source: Optional[str] = None,
+        data: Optional[Any] = None
+    ) -> ConsoleEvent:
+        """Log a warning message."""
+        pass
+    
+    @abstractmethod
+    def error(
+        self,
+        msg: str,
+        source: Optional[str] = None,
+        data: Optional[Any] = None,
+        stack: Optional[str] = None
+    ) -> ConsoleEvent:
+        """Log an error message."""
+        pass
+    
+    @abstractmethod
+    def debug(
+        self,
+        msg: str,
+        source: Optional[str] = None,
+        data: Optional[Any] = None
+    ) -> ConsoleEvent:
+        """Log a debug message."""
+        pass
+    
+    @abstractmethod
+    def get_events(
+        self,
+        event_type: Optional[ConsoleEventType] = None,
+        level: Optional[LogLevel] = None,
+        source: Optional[str] = None,
+        limit: Optional[int] = None
+    ) -> list[dict]:
+        """Get logged events as dictionaries."""
+        pass
+    
+    @abstractmethod
+    def clear(self) -> None:
+        """Clear all logged events."""
+        pass
+    
+    @abstractmethod
+    def count(self) -> int:
+        """Get the number of logged events."""
+        pass
+
+
+class AConsoleWriter(ABC, IConsoleWriter):
+    """
+    Abstract base class for console writing (user interaction, not logging).
+    
+    Can be used as a base class for bots and other user interaction systems.
+    """
+    
+    @abstractmethod
+    def write(self, text: str, **kwargs) -> None:
+        """Write text to console."""
+        pass
+    
+    @abstractmethod
+    def write_line(self, text: str = "", **kwargs) -> None:
+        """Write a line to console."""
+        pass
+    
+    @abstractmethod
+    def read(self, prompt: str = "") -> str:
+        """Read input from console."""
+        pass
+    
+    @abstractmethod
+    def clear(self) -> None:
+        """Clear console screen."""
+        pass
+
+
+__all__ = [
+    'AEventLogger',
+    'AConsoleWriter',
+]

exonware/xwsystem/console/cli/__init__.py

@@ -0,0 +1,61 @@
+#exonware/xwsystem/src/exonware/xwsystem/console/cli/__init__.py
+"""
+Command Line Interface (CLI) Utilities
+======================================
+
+Production-grade CLI utilities for XSystem.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.1.0.3
+Generated: 2025-01-27
+"""
+
+# Import general console enums from console level (priority)
+from ..defs import Colors, Style, Alignment, BorderStyle
+from .colors import colorize, CliColoredOutput
+from .args import CliArgumentParser, CliArgument, CliCommand, ArgumentType
+from .progress import CliProgressBar, CliSpinnerProgress, CliMultiProgress, CliProgressConfig
+from .tables import CliTable, CliTableFormatter, CliColumn
+from .console import CliConsole
+from .event_logger import CliEventLogger
+from .encoding import ensure_utf8_console
+
+__all__ = [
+    # General console enums (from console level)
+    'Colors', 
+    'Style',
+    'Alignment',
+    'BorderStyle',
+    
+    # Colors
+    'colorize',
+    'CliColoredOutput',
+    
+    # Arguments
+    'CliArgumentParser',
+    'CliArgument',
+    'CliCommand',
+    'ArgumentType',
+    
+    # Progress
+    'CliProgressBar',
+    'CliSpinnerProgress', 
+    'CliMultiProgress',
+    'CliProgressConfig',
+    
+    # Tables
+    'CliTable',
+    'CliTableFormatter',
+    'CliColumn',
+    
+    # Console (extends ConsoleWriter from console level)
+    'CliConsole',
+    
+    # Event Logger (extends logging.Logger)
+    'CliEventLogger',
+
+    # Encoding
+    'ensure_utf8_console',
+]

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.0.1.411
+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.0.1.411
+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