iso8583sim 1.1.0__py3-none-any.whl

iso8583sim/cli/__init__.py

@@ -0,0 +1,4 @@
+# iso8583sim/cli/__init__.py
+from .commands import app
+
+__all__ = ["app"]

iso8583sim/cli/commands.py

@@ -0,0 +1,314 @@
+import code
+import readline
+from pathlib import Path
+from typing import Any
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from ..core.builder import ISO8583Builder
+from ..core.parser import ISO8583Parser
+from ..core.types import (
+    CardNetwork,
+    ISO8583Message,
+    ISO8583Version,
+)
+from ..core.validator import ISO8583Validator
+from .config import ConfigManager
+from .formatter import CLIFormatter
+from .utils import (
+    create_template_message,
+    format_amount,
+    load_json_file,
+    save_json_file,
+    validate_pan,
+)
+
+# Initialize Typer app
+app = typer.Typer(
+    name="iso8583sim",
+    help="ISO 8583 Message Simulator - Parse, Build, and Test ISO 8583 messages",
+    add_completion=False,
+)
+
+# Initialize shared objects
+console = Console()
+formatter = CLIFormatter()
+config_manager = ConfigManager()
+
+
+class ISO8583Shell(code.InteractiveConsole):
+    """Enhanced interactive shell for ISO8583 simulation"""
+
+    def __init__(self, locals: dict[str, Any], history_file: Path):
+        super().__init__(locals)
+        self.history_file = history_file
+        self.console = Console()
+        self._setup_readline()
+
+    def _setup_readline(self):
+        """Setup readline with history and tab completion"""
+        # Enable tab completion
+        readline.parse_and_bind("tab: complete")
+
+        # Load history if exists
+        if self.history_file.exists():
+            readline.read_history_file(str(self.history_file))
+
+        # Set history length
+        readline.set_history_length(1000)
+
+    def interact(self, banner=None):
+        """Start the interactive shell"""
+        if banner is None:
+            banner = self._get_default_banner()
+
+        try:
+            super().interact(banner)
+        finally:
+            # Save history on exit
+            readline.write_history_file(str(self.history_file))
+
+    def _get_default_banner(self) -> str:
+        """Generate default banner with help text"""
+        return """
+[bold cyan]ISO 8583 Interactive Shell[/]
+[green]Available objects:[/]
+  - [yellow]parser[/]: ISO8583Parser instance
+  - [yellow]builder[/]: ISO8583Builder instance
+  - [yellow]validator[/]: ISO8583Validator instance
+  - [yellow]formatter[/]: CLIFormatter instance
+
+[green]Example usage:[/]
+  >>> msg = parser.parse("0100...")
+  >>> result = builder.build(msg)
+  >>> errors = validator.validate_message(msg)
+  >>> formatter.print_json(msg.fields)
+
+[green]Special commands:[/]
+  - [yellow]?obj[/]: Get help about an object
+  - [yellow]dir(obj)[/]: List object attributes
+  - [yellow]help(obj)[/]: Detailed help about an object
+
+[cyan]Type 'exit()' or press Ctrl+D to exit[/]
+"""
+
+    def push(self, line: str) -> bool:
+        """Process input line with error handling"""
+        try:
+            return super().push(line)
+        except Exception as e:
+            self.console.print(f"[red]Error:[/] {str(e)}")
+            return False
+
+    def raw_input(self, prompt=""):
+        """Override raw_input to use rich formatting"""
+        return super().raw_input(f"[cyan]{prompt}[/]")
+
+
+@app.command()
+def version():
+    """Display version information"""
+    console.print("[cyan]ISO8583 Simulator[/] [green]v0.1.0[/]")
+
+
+@app.command("parse")
+def parse_message(
+    message: str = typer.Argument(..., help="ISO 8583 message string to parse"),
+    version: str = typer.Option("1987", "--version", "-v", help="ISO 8583 version (1987, 1993, 2003)"),
+    network: str | None = typer.Option(None, "--network", "-n", help="Card network (VISA, MASTERCARD, AMEX, etc.)"),
+    output: Path | None = typer.Option(None, "--output", "-o", help="Output file for parsed message (JSON format)"),
+    format: str = typer.Option("table", "--format", "-f", help="Output format (table, json, tree)"),
+):
+    """Parse an ISO 8583 message and display its contents"""
+    try:
+        # Initialize parser
+        iso_version = ISO8583Version(version)
+        parser = ISO8583Parser(version=iso_version)
+
+        # Parse message with optional network
+        card_network = CardNetwork(network.upper()) if network else None
+        parsed = parser.parse(message, network=card_network)
+
+        # Format and display result based on format option
+        if format == "table":
+            table = formatter.format_field_table(parsed.fields)
+            console.print(table)
+        elif format == "json":
+            formatter.print_json(parsed.fields)
+        elif format == "tree":
+            tree = formatter.format_tree_view(parsed.__dict__)
+            console.print(tree)
+        else:
+            raise ValueError(f"Unknown format option: {format}")
+
+        # Save to file if requested
+        if output:
+            result = {"mti": parsed.mti, "version": version, "network": network, "fields": parsed.fields}
+            save_json_file(result, output)
+            console.print(f"\n[green]Results saved to {output}")
+
+    except Exception as e:
+        console.print(f"[red]Error parsing message: {str(e)}")
+        raise typer.Exit(1) from None
+
+
+@app.command("build")
+def build_message(
+    mti: str = typer.Option(..., "--mti", "-m", help="Message Type Indicator"),
+    fields_file: Path = typer.Option(..., "--fields", "-f", help="JSON file containing field values"),
+    version: str = typer.Option("1987", "--version", "-v", help="ISO 8583 version (1987, 1993, 2003)"),
+    network: str | None = typer.Option(None, "--network", "-n", help="Card network (VISA, MASTERCARD, AMEX, etc.)"),
+    output: Path | None = typer.Option(None, "--output", "-o", help="Output file for built message"),
+):
+    """Build an ISO 8583 message from field values"""
+    try:
+        # Load fields from JSON and convert string keys to integers
+        fields_data = {int(k): v for k, v in load_json_file(fields_file).items()}
+
+        # Initialize builder
+        iso_version = ISO8583Version(version)
+        builder = ISO8583Builder(version=iso_version)
+
+        # Create message with optional network
+        card_network = CardNetwork(network.upper()) if network else None
+        message = ISO8583Message(mti=mti, fields=fields_data, version=iso_version, network=card_network)
+
+        # Build message
+        result = builder.build(message)
+
+        # Display result
+        panel = Panel(result, title="Built ISO 8583 Message", border_style="cyan")
+        console.print(panel)
+
+        # Save to file if requested
+        if output:
+            output.write_text(result)
+            console.print(f"\n[green]Message saved to {output}")
+
+    except Exception as e:
+        console.print(f"[red]Error building message: {str(e)}")
+        raise typer.Exit(1) from None
+
+
+@app.command("validate")
+def validate_message(
+    message: str = typer.Argument(..., help="ISO 8583 message to validate"),
+    version: str = typer.Option("1987", "--version", "-v", help="ISO 8583 version (1987, 1993, 2003)"),
+    network: str | None = typer.Option(None, "--network", "-n", help="Card network (VISA, MASTERCARD, AMEX, etc.)"),
+):
+    """Validate an ISO 8583 message"""
+    try:
+        # Parse message first
+        iso_version = ISO8583Version(version)
+        parser = ISO8583Parser(version=iso_version)
+        card_network = CardNetwork(network.upper()) if network else None
+        parsed = parser.parse(message, network=card_network)
+
+        # Validate
+        validator = ISO8583Validator()
+        errors = validator.validate_message(parsed)
+
+        # Display results
+        panel = formatter.format_validation_results(errors)
+        console.print(panel)
+
+        if errors:
+            raise typer.Exit(1)
+
+    except Exception as e:
+        console.print(f"[red]Error validating message: {str(e)}")
+        raise typer.Exit(1) from None
+
+
+@app.command("generate")
+def generate_message(
+    type: str = typer.Option(..., "--type", "-t", help="Message type (auth, financial, reversal)"),
+    pan: str = typer.Option("4111111111111111", "--pan", "-p", help="Primary Account Number"),
+    amount: str = typer.Option("000000001000", "--amount", "-a", help="Transaction amount"),
+    currency: str = typer.Option("840", "--currency", "-c", help="Currency code (ISO 4217)"),
+    network: str | None = typer.Option(None, "--network", "-n", help="Card network (VISA, MASTERCARD, AMEX, etc.)"),
+    output: Path | None = typer.Option(None, "--output", "-o", help="Output file for generated message"),
+):
+    """Generate a sample ISO 8583 message"""
+    try:
+        # Create message template
+        message = create_template_message(get_mti_for_type(type), pan=validate_pan(pan), amount=format_amount(amount))
+
+        # Add network if specified
+        if network:
+            message["network"] = CardNetwork(network.upper())
+
+        # Add currency
+        message["fields"][49] = currency
+
+        # Build message
+        builder = ISO8583Builder()
+        iso_message = ISO8583Message(**message)
+        result = builder.build(iso_message)
+
+        # Display result
+        panel = Panel(result, title=f"Generated {type.title()} Message", border_style="cyan")
+        console.print(panel)
+
+        # Save to file if requested
+        if output:
+            output.write_text(result)
+            console.print(f"\n[green]Message saved to {output}")
+
+    except Exception as e:
+        console.print(f"[red]Error generating message: {str(e)}")
+        raise typer.Exit(1) from None
+
+
+@app.command("shell")
+def interactive_shell():
+    """Start an interactive ISO 8583 shell"""
+    try:
+        # Create instances of core components
+        parser = ISO8583Parser()
+        builder = ISO8583Builder()
+        validator = ISO8583Validator()
+
+        # Get history file from config
+        config = config_manager.get_config()
+        history_file = Path(config.history_file).expanduser()
+
+        # Create shell with local objects
+        locals_dict = {
+            "parser": parser,
+            "builder": builder,
+            "validator": validator,
+            "formatter": formatter,
+            "ISO8583Message": ISO8583Message,
+            "ISO8583Version": ISO8583Version,
+            "CardNetwork": CardNetwork,
+        }
+
+        # Create and start shell
+        shell = ISO8583Shell(locals_dict, history_file)
+        shell.interact()
+
+    except Exception as e:
+        console.print(f"[red]Error starting interactive shell: {str(e)}")
+        raise typer.Exit(1) from None
+
+
+def get_mti_for_type(type: str) -> str:
+    """Get MTI for message type"""
+    mti_map = {"auth": "0100", "financial": "0200", "reversal": "0400", "network": "0800"}
+
+    if type not in mti_map:
+        raise ValueError(f"Invalid message type. Choose from: {', '.join(mti_map.keys())}")
+
+    return mti_map[type]
+
+
+def main():
+    """Entry point for the CLI"""
+    app()
+
+
+if __name__ == "__main__":
+    main()

iso8583sim/cli/config.py

@@ -0,0 +1,65 @@
+# iso8583sim/cli/config.py
+import json
+from pathlib import Path
+
+import typer
+from pydantic import BaseModel
+
+
+class CLIConfig(BaseModel):
+    """CLI Configuration Model"""
+
+    default_version: str = "1987"
+    output_directory: str = "./output"
+    templates_directory: str = "./templates"
+    log_level: str = "INFO"
+    color_output: bool = True
+    save_history: bool = True
+    history_file: str = "~/.iso8583sim_history"
+    default_currency: str = "840"
+    default_terminal_id: str = "TEST1234"
+    default_merchant_id: str = "MERCHANT123456789"
+
+
+class ConfigManager:
+    def __init__(self):
+        self.app_dir = typer.get_app_dir("iso8583sim")
+        self.config_file = Path(self.app_dir) / "config.json"
+        self.config = self._load_config()
+
+    def _load_config(self) -> CLIConfig:
+        """Load configuration from file or create default"""
+        try:
+            if self.config_file.exists():
+                config_data = json.loads(self.config_file.read_text())
+                return CLIConfig(**config_data)
+            else:
+                return self._create_default_config()
+        except Exception as e:
+            print(f"Error loading config: {e}. Using defaults.")
+            return CLIConfig()
+
+    def _create_default_config(self) -> CLIConfig:
+        """Create default configuration file"""
+        config = CLIConfig()
+        self._save_config(config)
+        return config
+
+    def _save_config(self, config: CLIConfig):
+        """Save configuration to file"""
+        try:
+            Path(self.app_dir).mkdir(parents=True, exist_ok=True)
+            self.config_file.write_text(config.model_dump_json(indent=2))
+        except Exception as e:
+            print(f"Error saving config: {e}")
+
+    def update_config(self, **kwargs):
+        """Update configuration with new values"""
+        config_data = self.config.model_dump()
+        config_data.update(kwargs)
+        self.config = CLIConfig(**config_data)
+        self._save_config(self.config)
+
+    def get_config(self) -> CLIConfig:
+        """Get current configuration"""
+        return self.config

iso8583sim/cli/formatter.py

@@ -0,0 +1,110 @@
+# iso8583sim/cli/formatter.py
+import json
+from typing import Any
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.tree import Tree
+
+
+class CLIFormatter:
+    def __init__(self):
+        self.console = Console()
+
+    def format_message(self, message: dict[str, Any]) -> Panel:
+        """Format ISO message for display"""
+        content = []
+        content.append(f"[cyan]MTI:[/] {message.get('mti', 'N/A')}")
+        content.append(f"[cyan]Version:[/] {message.get('version', 'N/A')}")
+
+        fields = message.get("fields", {})
+        if fields:
+            content.append("\n[cyan]Fields:[/]")
+            for field_num, value in sorted(fields.items()):
+                content.append(f"  Field {field_num}: {value}")
+
+        return Panel("\n".join(content), title="ISO 8583 Message", border_style="cyan")
+
+    def format_validation_results(self, errors: list[str]) -> Panel:
+        """Format validation results"""
+        if not errors:
+            return Panel("[green]✓ Message is valid[/]", title="Validation Results", border_style="green")
+
+        content = ["[red]The following errors were found:[/]"]
+        for error in errors:
+            content.append(f"[red]✗[/] {error}")
+
+        return Panel("\n".join(content), title="Validation Results", border_style="red")
+
+    def format_field_table(self, fields: dict[int, str]) -> Table:
+        """Create table of message fields"""
+        table = Table(title="Message Fields")
+        table.add_column("Field Number", style="cyan")
+        table.add_column("Description", style="green")
+        table.add_column("Value", style="yellow")
+        table.add_column("Length", style="magenta")
+
+        for field_num, value in sorted(fields.items()):
+            table.add_row(str(field_num), self.get_field_description(field_num), value, str(len(value)))
+
+        return table
+
+    def format_tree_view(self, message: dict[str, Any]) -> Tree:
+        """Create tree view of message structure"""
+        tree = Tree("ISO 8583 Message")
+        tree.add(f"MTI: {message.get('mti', 'N/A')}")
+        tree.add(f"Version: {message.get('version', 'N/A')}")
+
+        fields_branch = tree.add("Fields")
+        for field_num, value in sorted(message.get("fields", {}).items()):
+            fields_branch.add(f"Field {field_num}: {value}")
+
+        return tree
+
+    @staticmethod
+    def get_field_description(field_num: int) -> str:
+        """Get description for field number"""
+        # This could be expanded with a complete field description mapping
+        descriptions = {
+            0: "Message Type Indicator",
+            2: "Primary Account Number",
+            3: "Processing Code",
+            4: "Amount, Transaction",
+            11: "Systems Trace Audit Number",
+            12: "Time, Local Transaction",
+            13: "Date, Local Transaction",
+            37: "Retrieval Reference Number",
+            39: "Response Code",
+            41: "Card Acceptor Terminal ID",
+            42: "Card Acceptor ID Code",
+        }
+        return descriptions.get(field_num, "Field Description Not Available")
+
+    def print_success(self, message: str):
+        """Print success message"""
+        self.console.print(f"[green]✓[/] {message}")
+
+    def print_error(self, message: str):
+        """Print error message"""
+        self.console.print(f"[red]✗[/] {message}")
+
+    def print_warning(self, message: str):
+        """Print warning message"""
+        self.console.print(f"[yellow]![/] {message}")
+
+    def print_info(self, message: str):
+        """Print info message"""
+        self.console.print(f"[blue]i[/] {message}")
+
+    def format_json(self, data: dict[str, Any]) -> str:
+        """Format data as colored JSON"""
+        # Just return the formatted JSON string
+        return json.dumps(data, indent=2)
+
+    def print_json(self, data: dict[str, Any]):
+        """Print data as syntax-highlighted JSON"""
+        # Use Syntax for display but don't return it
+        syntax = Syntax(json.dumps(data, indent=2), "json", theme="monokai", line_numbers=True)
+        self.console.print(syntax)

iso8583sim/cli/utils.py

@@ -0,0 +1,128 @@
+# iso8583sim/cli/utils.py
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import typer
+
+
+def load_json_file(file_path: Path) -> dict[str, Any]:
+    """Load and validate JSON file"""
+    try:
+        with open(file_path) as f:
+            return json.load(f)
+    except json.JSONDecodeError:
+        raise typer.BadParameter(f"Invalid JSON file: {file_path}") from None
+    except FileNotFoundError:
+        raise typer.BadParameter(f"File not found: {file_path}") from None
+
+
+def save_json_file(data: dict[str, Any], file_path: Path):
+    """Save data to JSON file"""
+    try:
+        with open(file_path, "w") as f:
+            json.dump(data, f, indent=2)
+    except Exception as e:
+        raise typer.BadParameter(f"Error saving file: {e}") from None
+
+
+def generate_output_filename(prefix: str, suffix: str = "") -> str:
+    """Generate unique output filename with timestamp"""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    return f"{prefix}_{timestamp}{suffix}"
+
+
+def ensure_directory(directory: Path):
+    """Ensure directory exists"""
+    directory.mkdir(parents=True, exist_ok=True)
+
+
+def validate_file_path(file_path: Path, create_dir: bool = True) -> Path:
+    """Validate and prepare file path"""
+    if create_dir:
+        ensure_directory(file_path.parent)
+    return file_path
+
+
+def format_amount(amount: str) -> str:
+    """Format numeric amount with proper padding"""
+    try:
+        # Remove any decimal points and convert to integer
+        num = int(float(amount) * 100)
+        # Return 12-digit zero-padded string
+        return f"{num:012d}"
+    except ValueError:
+        raise typer.BadParameter("Invalid amount format") from None
+
+
+def validate_pan(pan: str) -> str:
+    """Validate PAN using Luhn algorithm"""
+    if not pan.isdigit():
+        raise typer.BadParameter("PAN must contain only digits")
+
+    # Luhn algorithm check
+    digits = [int(d) for d in pan]
+    checksum = 0
+    for i in range(len(digits) - 2, -1, -1):
+        d = digits[i]
+        if i % 2 == len(digits) % 2:
+            d *= 2
+            if d > 9:
+                d -= 9
+        checksum += d
+
+    if (checksum + digits[-1]) % 10 != 0:
+        raise typer.BadParameter("Invalid PAN (failed Luhn check)")
+
+    return pan
+
+
+def create_template_message(
+    mti: str, pan: str | None = None, amount: str | None = None, terminal_id: str | None = None
+) -> dict[str, Any]:
+    """Create template message with common fields"""
+    now = datetime.now()
+
+    message = {
+        "mti": mti,
+        "fields": {
+            11: now.strftime("%H%M%S"),  # STAN
+            12: now.strftime("%H%M%S"),  # Time
+            13: now.strftime("%m%d"),  # Date
+        },
+    }
+
+    if pan:
+        message["fields"][2] = validate_pan(pan)
+
+    if amount:
+        message["fields"][4] = format_amount(amount)
+
+    if terminal_id:
+        message["fields"][41] = terminal_id
+
+    return message
+
+
+def get_response_code_description(code: str) -> str:
+    """Get description for response code"""
+    descriptions = {
+        "00": "Approved",
+        "01": "Refer to card issuer",
+        "02": "Refer to card issuer, special condition",
+        "03": "Invalid merchant",
+        "04": "Pick up card",
+        "05": "Do not honor",
+        "06": "Error",
+        "07": "Pick up card, special condition",
+        "08": "Honor with identification",
+        "09": "Request in progress",
+        "10": "Approved, partial",
+        "11": "Approved, VIP",
+        "12": "Invalid transaction",
+        "13": "Invalid amount",
+        "14": "Invalid card number",
+        "15": "No such issuer",
+    }
+    return descriptions.get(code, "Unknown response code")

iso8583sim/core/__init__.py

@@ -0,0 +1,57 @@
+"""Core module for ISO 8583 message handling.
+
+This module provides the fundamental building blocks for working with
+ISO 8583 financial transaction messages:
+
+- **Types**: Data types, enums, and field definitions
+- **Parser**: Parse raw message strings into structured objects
+- **Builder**: Build raw message strings from objects
+- **Validator**: Validate message structure and content
+- **EMV**: Handle Field 55 chip card data (TLV format)
+- **Pool**: Object pooling for high-throughput scenarios
+"""
+
+from .builder import ISO8583Builder
+from .emv import build_emv_data, parse_emv_data
+from .parser import ISO8583Parser
+from .pool import MessagePool
+from .types import (
+    BuildError,
+    CardNetwork,
+    FieldDefinition,
+    FieldType,
+    ISO8583Message,
+    ISO8583Version,
+    MessageClass,
+    MessageFunction,
+    ParseError,
+    detect_network,
+    get_field_definition,
+)
+from .validator import ISO8583Validator
+
+__all__ = [
+    # Parser
+    "ISO8583Parser",
+    # Builder
+    "ISO8583Builder",
+    # Validator
+    "ISO8583Validator",
+    # Types
+    "ISO8583Message",
+    "ISO8583Version",
+    "FieldType",
+    "FieldDefinition",
+    "CardNetwork",
+    "MessageClass",
+    "MessageFunction",
+    "ParseError",
+    "BuildError",
+    "get_field_definition",
+    "detect_network",
+    # EMV
+    "parse_emv_data",
+    "build_emv_data",
+    # Pool
+    "MessagePool",
+]