pyboomi-cli 0.2.5__py3-none-any.whl

pyboomi_cli/__init__.py

@@ -0,0 +1,55 @@
+# PyBoomi CLI - Main Package
+#
+# Copyright 2025 Robert Little
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Development Notes:
+#     Contents of this file were produced with the help of code generation tools
+#     and subsequently reviewed and edited by the author. While some code was
+#     created with AI assistance, manual adjustments have been made to ensure
+#     correctness, readability, functionality, and compliance with coding
+#     standards. Any future modifications should preserve these manual changes.
+#
+# Author: Robert Little
+# Created: 2025-07-27
+
+"""
+PyBoomi CLI - Command-line interface for the Boomi Platform API.
+
+This package provides a comprehensive command-line tool for interacting with
+the Boomi Platform API. It enables developers and system administrators to
+manage Boomi integrations, processes, folders, and other platform resources
+directly from the terminal.
+"""
+
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("pyboomi-cli")
+except PackageNotFoundError:
+    __version__ = "0.0.0.dev0"
+
+__author__ = "Robert Little"
+__copyright__ = "Copyright 2025, Robert Little"
+__license__ = "Apache 2.0"
+
+# Import main CLI function for easy access
+from .cli import main
+
+__all__ = [
+    "__version__",
+    "__author__",
+    "__license__",
+    "main",
+]

pyboomi_cli/cache.py

@@ -0,0 +1,111 @@
+# PyBoomi CLI - Cache Management
+#
+# Copyright 2025 Robert Little
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Cache management for PyBoomi CLI components."""
+
+import hashlib
+import os
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Optional, Tuple
+
+
+def get_cache_dir() -> Path:
+    """Get the cache directory path, cross-platform compatible."""
+    from pyboomi_cli.config import get_config
+
+    config = get_config()
+
+    if config and "cache_dir" in config:
+        return Path(config["cache_dir"]).expanduser()
+
+    # Default to .boomicache in user home directory
+    home = Path.home()
+    return home / ".boomicache"
+
+
+def get_cache_key(component_id: str, branch_id: str, version: str) -> str:
+    """Generate a cache key for a component. Requires both branch_id and version."""
+    key_string = f"{component_id}|branch:{branch_id}|version:{version}"
+    return hashlib.sha256(key_string.encode()).hexdigest()
+
+
+def extract_component_info(component_xml: str) -> Tuple[Optional[str], Optional[str]]:
+    """Extract branch ID and version from component XML."""
+    try:
+        root = ET.fromstring(component_xml)
+        # Look for common attributes that contain branch and version info
+        branch_id = root.get("branchId") or root.get("branch-id")
+        version = root.get("version") or root.get("revision")
+        return branch_id, version
+    except Exception:
+        return None, None
+
+
+def get_cached_component(
+    component_id: str, branch_id: Optional[str] = None, version: Optional[str] = None
+) -> Optional[str]:
+    """
+    Retrieve a component from cache if it exists.
+
+    Only works with specific branch_id and version.
+    """
+    if not branch_id or not version:
+        return None  # Don't cache without specific branch and version
+
+    try:
+        cache_dir = get_cache_dir()
+        if not cache_dir.exists():
+            return None
+
+        cache_key = get_cache_key(component_id, branch_id, version)
+        cache_file = cache_dir / f"{cache_key}.xml"
+
+        if cache_file.exists():
+            return cache_file.read_text(encoding="utf-8")
+    except Exception:
+        pass
+
+    return None
+
+
+def cache_component(
+    component_data: str,
+    component_id: str,
+    branch_id: Optional[str] = None,
+    version: Optional[str] = None,
+) -> None:
+    """Store a component in the cache. Only caches with specific branch_id and version."""
+    # If branch_id or version not provided, try to extract from component XML
+    if not branch_id or not version:
+        extracted_branch, extracted_version = extract_component_info(component_data)
+        branch_id = branch_id or extracted_branch
+        version = version or extracted_version
+
+    # Only cache if we have both branch and version
+    if not branch_id or not version:
+        return
+
+    try:
+        cache_dir = get_cache_dir()
+        cache_dir.mkdir(parents=True, exist_ok=True)
+
+        cache_key = get_cache_key(component_id, branch_id, version)
+        cache_file = cache_dir / f"{cache_key}.xml"
+
+        cache_file.write_text(component_data, encoding="utf-8")
+    except Exception:
+        pass  # Silently fail if caching doesn't work

pyboomi_cli/cli.py

@@ -0,0 +1,59 @@
+# PyBoomi CLI - CLI Main
+#
+# Copyright 2025 Robert Little
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Development Notes:
+#     Contents of this file were produced with the help of code generation tools
+#     and subsequently reviewed and edited by the author. While some code was
+#     created with AI assistance, manual adjustments have been made to ensure
+#     correctness, readability, functionality, and compliance with coding
+#     standards. Any future modifications should preserve these manual changes.
+#
+# Author: Robert Little
+# Created: 2025-12-12
+
+"""CLI main module for PyBoomi CLI tool."""
+
+__author__ = "Robert Little"
+__copyright__ = "Copyright 2025, Robert Little"
+__license__ = "Apache 2.0"
+__version__ = "0.1.0"
+
+import click
+
+from pyboomi_cli.commands.branch import command as branch_command
+from pyboomi_cli.commands.component import command as component_command
+from pyboomi_cli.commands.environment import command as environment_command
+from pyboomi_cli.commands.folders import command as folders_command
+from pyboomi_cli.commands.package import command as package_command
+from pyboomi_cli.commands.processes import command as processes_command
+
+
+@click.group()
+def main():
+    """PyBoomi CLI — manage Boomi Platform API from the terminal."""
+    pass
+
+
+main.add_command(folders_command)
+# Plural alias for backward compatibility
+main.add_command(folders_command, name="folders")
+main.add_command(processes_command, name="processes")
+main.add_command(processes_command, name="process")
+main.add_command(component_command)
+main.add_command(package_command)
+main.add_command(branch_command)
+main.add_command(environment_command)
+main.add_command(environment_command, name="environments")

pyboomi_cli/config.py

@@ -0,0 +1,48 @@
+# PyBoomi CLI - Configuration Management
+#
+# Copyright 2025 Robert Little
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Configuration management for PyBoomi CLI."""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+def get_config_file_path() -> Path:
+    """Get the configuration file path."""
+    # Check for config file in current directory first
+    local_config = Path(".pyboomi.json")
+    if local_config.exists():
+        return local_config
+
+    # Check in user home directory
+    home_config = Path.home() / ".pyboomi.json"
+    return home_config
+
+
+def get_config() -> Optional[Dict[str, Any]]:
+    """Load configuration from file if it exists."""
+    config_file = get_config_file_path()
+
+    if not config_file.exists():
+        return None
+
+    try:
+        with open(config_file, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return None

pyboomi_cli/utils.py

@@ -0,0 +1,565 @@
+# PyBoomi CLI - Utilities
+#
+# Copyright 2025 Robert Little
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# Development Notes:
+#     Contents of this file were produced with the help of code generation tools
+#     and subsequently reviewed and edited by the author. While some code was
+#     created with AI assistance, manual adjustments have been made to ensure
+#     correctness, readability, functionality, and compliance with coding
+#     standards. Any future modifications should preserve these manual changes.
+#
+# Author: Robert Little
+# Created: 2025-01-27
+
+"""Utility functions for PyBoomi CLI operations."""
+
+__author__ = "Robert Little"
+__copyright__ = "Copyright 2025, Robert Little"
+__license__ = "Apache 2.0"
+__version__ = "0.1.0"
+
+import json
+import os
+import re
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+
+import click
+from pyboomi_platform.auth import BoomiAuth
+from pyboomi_platform.client import BoomiPlatformClient
+
+
+def _apply_accept_header(client, accept: Optional[str]) -> None:
+    """
+    Best-effort application of an Accept header on the underlying client/session.
+    Supports multiple possible client shapes without failing hard.
+    """
+    if not accept:
+        return
+
+    applied = False
+
+    # Common requests-style session
+    session = getattr(client, "session", None)
+    if session and hasattr(session, "headers"):
+        try:
+            session.headers["Accept"] = accept
+            applied = True
+        except Exception:
+            pass
+
+    # Some clients expose default_headers dict
+    default_headers = getattr(client, "default_headers", None)
+    if isinstance(default_headers, dict):
+        try:
+            default_headers["Accept"] = accept
+            applied = True
+        except Exception:
+            pass
+
+    # Fallback attribute for downstream use if the client inspects it
+    if not applied:
+        try:
+            setattr(client, "accept", accept)
+        except Exception:
+            pass
+
+
+def get_client(account_id=None, username=None, api_token=None, accept: Optional[str] = None):
+    """
+    Get a configured BoomiPlatformClient with authentication.
+
+    Priority for credentials:
+    - BOOMI_AUTH (base64 encoded Basic Auth string)
+    - Function arguments (username, api_token)
+    - Environment variables (BOOMI_USER, BOOMI_TOKEN)
+
+    Account ID can come from function argument or BOOMI_ACCT env var.
+
+    Args:
+        account_id: Boomi account ID (optional, can use BOOMI_ACCT env var)
+        username: Boomi user email (optional, can use BOOMI_USER env var)
+        api_token: Boomi Platform API token (optional, can use BOOMI_TOKEN env var)
+
+    Returns:
+        BoomiPlatformClient: Configured client instance with optional Accept header
+
+    Raises:
+        click.UsageError: If required credentials are missing
+    """
+    account_id = account_id or os.getenv("BOOMI_ACCT")
+    if not account_id:
+        raise click.UsageError("Boomi account ID must be provided via --account-id or BOOMI_ACCT environment variable.")
+
+    boomi_auth_header = os.getenv("BOOMI_AUTH")
+
+    if boomi_auth_header:
+        # BOOMI_AUTH is base64 encoded "BOOMI_TOKEN.email:uuid"
+        # Extract username and password for client initialization
+        try:
+            import base64
+
+            decoded = base64.b64decode(boomi_auth_header).decode("utf-8")
+            if ":" in decoded:
+                # Format is "BOOMI_TOKEN.email:uuid"
+                client_username, client_api_token = decoded.split(":", 1)
+            else:
+                # Fallback if no colon found
+                client_username = decoded
+                client_api_token = "token"
+        except Exception:
+            # If decoding fails, use placeholders
+            client_username = "user"
+            client_api_token = "token"
+
+        # Construct a fake BoomiAuth wrapper that returns the existing auth header
+        # The header is already base64 encoded, so we use it directly
+        class StaticBoomiAuth:
+            """Wrapper for pre-encoded Basic Auth header."""
+
+            def get_auth_header(self):
+                """Return pre-encoded authorization header."""
+                return {"Authorization": f"Basic {boomi_auth_header}"}
+
+        auth = StaticBoomiAuth()
+    else:
+        username = username or os.getenv("BOOMI_USER")
+        api_token = api_token or os.getenv("BOOMI_TOKEN")
+
+        if not username or not api_token:
+            raise click.UsageError(
+                "You must provide credentials using either:\n"
+                "- BOOMI_AUTH (base64 encoded Basic Auth string), or\n"
+                "- --username and --api-token (or BOOMI_USER and BOOMI_TOKEN env vars)"
+            )
+        auth = BoomiAuth(username, api_token)
+        client_username = username
+        client_api_token = api_token
+
+    # Inject the custom auth into the client
+    client = BoomiPlatformClient(account_id, username=client_username, api_token=client_api_token, base_url=None)
+    client.auth = auth
+
+    # Apply Accept header if requested (e.g., force XML responses)
+    _apply_accept_header(client, accept)
+
+    return client
+
+
+def sanitize_filename(name: str) -> str:
+    """
+    Sanitize a filename by removing filesystem-unsafe characters.
+
+    Removes or replaces characters that are not safe for filesystem use:
+    /, \\, :, *, ?, ", <, >, |
+
+    Args:
+        name: Original filename string
+
+    Returns:
+        str: Sanitized filename safe for filesystem use
+    """
+    if not name:
+        return "unknown"
+
+    # Remove filesystem-unsafe characters
+    unsafe_chars = r'[/\\:*?"<>|]'
+    sanitized = re.sub(unsafe_chars, "", name)
+
+    # Replace spaces with underscores for better filesystem compatibility
+    sanitized = sanitized.replace(" ", "_")
+
+    # Remove leading/trailing dots and spaces (Windows issue)
+    sanitized = sanitized.strip(". ")
+
+    # If empty after sanitization, return a default
+    if not sanitized:
+        return "unknown"
+
+    return sanitized
+
+
+def format_output(data, output_format="json"):
+    """
+    Format data for output in the specified format.
+
+    Args:
+        data: Data to format (dict, list, etc.)
+        output_format: Output format ('json', 'yaml', or 'text')
+
+    Returns:
+        str: Formatted output string
+    """
+    if output_format == "json":
+        return json.dumps(data, indent=2)
+    elif output_format == "yaml":
+        try:
+            import yaml
+
+            return yaml.dump(data, default_flow_style=False, sort_keys=False)
+        except ImportError:
+            click.echo("Warning: PyYAML not installed. Falling back to JSON format.", err=True)
+            return json.dumps(data, indent=2)
+    elif output_format == "text":
+        # Simple text formatting for common component fields
+        if isinstance(data, dict):
+            lines = []
+            for key, value in data.items():
+                if isinstance(value, (dict, list)):
+                    lines.append(f"{key}:")
+                    lines.append(json.dumps(value, indent=2))
+                else:
+                    lines.append(f"{key}: {value}")
+            return "\n".join(lines)
+        else:
+            return str(data)
+    elif output_format == "xml":
+        # For XML we expect a string or bytes payload; pass through as text
+        if isinstance(data, bytes):
+            return data.decode("utf-8", errors="replace")
+        return str(data)
+    else:
+        # Default to JSON
+        return json.dumps(data, indent=2)
+
+
+def get_templates_directory() -> Path:
+    """
+    Get the templates directory path.
+
+    Checks in order:
+    1. Environment variable PYBOOMI_TEMPLATES_DIR
+    2. Current working directory 'templates/'
+    3. User home directory '~/.pyboomi-cli/templates/'
+
+    Returns:
+        Path: Path to templates directory
+    """
+    # Check environment variable first
+    env_path = os.getenv("PYBOOMI_TEMPLATES_DIR")
+    if env_path:
+        return Path(env_path).expanduser()
+
+    # Check current working directory
+    cwd_templates = Path.cwd() / "templates"
+    if cwd_templates.exists():
+        return cwd_templates
+
+    # Default to current working directory (will be created if needed)
+    return Path.cwd() / "templates"
+
+
+def find_template_file(template_path: str, component_type: Optional[str] = None) -> Path:
+    """
+    Find a template file by path.
+
+    The template_path can be:
+    - A relative path from templates directory (e.g., "processes/basic.xml")
+    - An absolute path
+    - A filename that will be searched in component_type subdirectory
+
+    Args:
+        template_path: Path to template file
+        component_type: Optional component type subdirectory (e.g., "processes")
+
+    Returns:
+        Path: Path to template file
+
+    Raises:
+        click.UsageError: If template file is not found
+    """
+    template_path_obj = Path(template_path)
+
+    # If it's an absolute path and exists, use it
+    if template_path_obj.is_absolute() and template_path_obj.exists():
+        return template_path_obj
+
+    # Get templates directory
+    templates_dir = get_templates_directory()
+
+    # If template_path contains a slash, treat as relative to templates_dir
+    if "/" in template_path or "\\" in template_path:
+        full_path = templates_dir / template_path
+        if full_path.exists():
+            return full_path
+
+    # Otherwise, search in component_type subdirectory
+    if component_type:
+        full_path = templates_dir / component_type / template_path
+        if full_path.exists():
+            return full_path
+
+    # Try just in templates_dir
+    full_path = templates_dir / template_path
+    if full_path.exists():
+        return full_path
+
+    # Not found
+    raise click.UsageError(
+        f"Template file not found: {template_path}\n"
+        f"Searched in: {templates_dir}" + (f"/{component_type}" if component_type else "")
+    )
+
+
+def scan_template_parameters(template_content: str) -> Dict[str, Optional[str]]:
+    """
+    Scan template content for all unique template parameters.
+
+    Template parameters use {{parameterName}} or {{parameterName:default value}} syntax.
+    Default values can span multiple lines.
+
+    Args:
+        template_content: Template file content as string
+
+    Returns:
+        Dict[str, Optional[str]]: Dictionary mapping parameter names to their default values
+                                  (None if no default provided)
+    """
+    parameters = {}
+
+    # Pattern to match {{parameterName:default value}} (with default, supports multi-line)
+    # Uses non-greedy matching to stop at the first }} (closing braces)
+    # The (?s) flag makes . match newlines
+    pattern_with_default = r"\{\{(\w+):(.*?)\}\}"
+    matches_with_default = re.findall(pattern_with_default, template_content, re.DOTALL)
+    for param_name, default_value in matches_with_default:
+        # Strip leading/trailing whitespace but preserve internal structure
+        parameters[param_name] = default_value.strip()
+
+    # Pattern to match {{parameterName}} (without default)
+    # But exclude those that were already matched with defaults
+    pattern_no_default = r"\{\{(\w+)\}\}"
+    matches_no_default = re.findall(pattern_no_default, template_content)
+    for param_name in matches_no_default:
+        # Only add if not already found with a default value
+        if param_name not in parameters:
+            parameters[param_name] = None
+
+    return parameters
+
+
+def display_template_parameter_summary(
+    parameters: Dict[str, Optional[str]],
+    provided_values: Optional[Dict[str, str]] = None,
+) -> None:
+    """
+    Display a summary of template parameters to the user.
+
+    Shows all parameters, indicating which have defaults, which are already provided,
+    and which still need values.
+
+    Args:
+        parameters: Dictionary mapping parameter names to their default values (None if no default)
+        provided_values: Optional dictionary of already-provided parameter values
+    """
+    if not parameters:
+        return
+
+    if provided_values is None:
+        provided_values = {}
+
+    click.echo("\n" + "=" * 70)
+    click.echo("Template Parameter Summary")
+    click.echo("=" * 70)
+
+    # Separate parameters into categories
+    with_defaults = []
+    without_defaults = []
+    already_provided = []
+
+    for param_name in sorted(parameters.keys()):
+        if param_name in provided_values:
+            already_provided.append((param_name, provided_values[param_name]))
+        elif parameters[param_name] is not None:
+            with_defaults.append((param_name, parameters[param_name]))
+        else:
+            without_defaults.append(param_name)
+
+    # Display already provided parameters
+    if already_provided:
+        click.echo("\n✓ Already Provided:")
+        for param_name, value in already_provided:
+            # Truncate long values for display
+            display_value = value if len(value) <= 60 else value[:57] + "..."
+            if "\n" in display_value:
+                display_value = display_value.split("\n")[0] + " ... (multi-line)"
+            click.echo(f"  • {param_name}: {display_value}")
+
+    # Display parameters with defaults
+    if with_defaults:
+        click.echo("\nParameters with Default Values:")
+        for param_name, default_value in with_defaults:
+            # Truncate long defaults for display
+            display_default = default_value if len(default_value) <= 60 else default_value[:57] + "..."
+            if "\n" in display_default:
+                display_default = display_default.split("\n")[0] + " ... (multi-line)"
+            click.echo(f"  • {param_name}")
+            click.echo(f"    Default: {display_default}")
+
+    # Display parameters without defaults
+    if without_defaults:
+        click.echo("\nParameters Requiring Values (no defaults):")
+        for param_name in without_defaults:
+            click.echo(f"  • {param_name}")
+
+    click.echo("\n" + "=" * 70)
+
+
+def prompt_for_template_parameters(
+    parameters: Dict[str, Optional[str]],
+    existing_values: Optional[Dict[str, str]] = None,
+) -> Dict[str, str]:
+    """
+    Prompt user for values for all template parameters.
+
+    Args:
+        parameters: Dictionary mapping parameter names to their default values (None if no default)
+        existing_values: Optional dict of pre-filled values (won't prompt for these)
+
+    Returns:
+        Dict[str, str]: Dictionary mapping parameter names to values
+    """
+    if existing_values is None:
+        existing_values = {}
+
+    values = {}
+    sorted_params = sorted(parameters.keys())
+
+    for param in sorted_params:
+        if param in existing_values:
+            values[param] = existing_values[param]
+            click.echo(f"{param}: {existing_values[param]} (using provided value)")
+        else:
+            # Convert parameter name to a more readable prompt
+            prompt_text = param.replace("_", " ").replace("-", " ").title()
+            default_value = parameters.get(param)
+
+            if default_value is not None:
+                # Use default value in prompt
+                value = click.prompt(
+                    f"Enter value for {prompt_text} ({param})",
+                    default=default_value,
+                    type=str,
+                )
+            else:
+                # No default, require input
+                value = click.prompt(f"Enter value for {prompt_text} ({param})", type=str)
+            values[param] = value
+
+    return values
+
+
+def replace_template_parameters(template_content: str, parameter_values: Dict[str, str]) -> str:
+    """
+    Replace template parameters with provided values.
+
+    Handles both formats:
+    - {{parameterName}} (no default)
+    - {{parameterName:default value}} (with default, supports multi-line)
+
+    Args:
+        template_content: Template content with {{parameterName}} or {{parameterName:default}} placeholders
+        parameter_values: Dictionary mapping parameter names to values
+
+    Returns:
+        str: Template content with parameters replaced
+    """
+    result = template_content
+    for param_name, param_value in parameter_values.items():
+        # Replace {{paramName:default}} format first (more specific, supports multi-line)
+        # Use non-greedy matching with DOTALL flag to handle multi-line defaults
+        pattern_with_default = r"\{\{" + re.escape(param_name) + r":.*?\}\}"
+        result = re.sub(pattern_with_default, str(param_value), result, flags=re.DOTALL)
+
+        # Then replace {{paramName}} format (no default)
+        pattern_no_default = r"\{\{" + re.escape(param_name) + r"\}\}"
+        result = re.sub(pattern_no_default, str(param_value), result)
+    return result
+
+
+def load_and_process_template(
+    template_path: str,
+    component_type: Optional[str] = None,
+    parameter_values: Optional[Dict[str, str]] = None,
+    prompt_missing: bool = True,
+) -> str:
+    """
+    Load a template file, scan for parameters, prompt for values, and replace them.
+
+    Args:
+        template_path: Path to template file
+        component_type: Optional component type subdirectory
+        parameter_values: Optional pre-filled parameter values
+        prompt_missing: Whether to prompt for missing parameters (default: True)
+
+    Returns:
+        str: Processed template content with all parameters replaced
+    """
+    # Find and load template file
+    template_file = find_template_file(template_path, component_type)
+
+    try:
+        with open(template_file, "r", encoding="utf-8") as f:
+            template_content = f.read()
+    except Exception as e:
+        raise click.UsageError(f"Error reading template file {template_file}: {e}")
+
+    # Scan for parameters (returns dict with parameter names and default values)
+    parameters = scan_template_parameters(template_content)
+
+    if not parameters:
+        # No parameters to replace, return as-is
+        return template_content
+
+    # Get parameter values
+    if parameter_values is None:
+        parameter_values = {}
+
+    # Prompt for missing parameters if requested
+    if prompt_missing:
+        missing_params = {k: v for k, v in parameters.items() if k not in parameter_values}
+        if missing_params:
+            # Display summary of all parameters (including those already provided)
+            display_template_parameter_summary(parameters, parameter_values)
+
+            # Ask user if they want to continue or abort
+            click.echo("\nYou can proceed to provide values for the missing parameters,")
+            click.echo("or abort now to gather the necessary information first.")
+            if not click.confirm("\nDo you want to continue with parameter entry?", default=True):
+                click.echo("\nOperation cancelled. Please gather the required information and try again.")
+                raise click.Abort()
+
+            click.echo(f"\nTemplate contains {len(missing_params)} parameter(s) that need values:")
+            prompted_values = prompt_for_template_parameters(missing_params, parameter_values)
+            parameter_values.update(prompted_values)
+    else:
+        # If not prompting, apply default values for parameters that don't have values yet
+        for param_name, default_value in parameters.items():
+            if param_name not in parameter_values and default_value is not None:
+                parameter_values[param_name] = default_value
+
+    # Check that all parameters have values
+    missing = set(parameters.keys()) - set(parameter_values.keys())
+    if missing:
+        raise click.UsageError(
+            f"Missing values for template parameters: {', '.join(sorted(missing))}\n"
+            f"Please provide values for all parameters."
+        )
+
+    # Replace parameters
+    processed_content = replace_template_parameters(template_content, parameter_values)
+
+    return processed_content

pyboomi_cli-0.2.5.dist-info/METADATA

@@ -0,0 +1,210 @@
+Metadata-Version: 2.4
+Name: pyboomi-cli
+Version: 0.2.5
+Summary: Command-line interface for Boomi Platform API
+Author-email: Robert Little <robert@iesoftwaredeveloper.com>
+Maintainer-email: Robert Little <robert@iesoftwaredeveloper.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/iesoftwaredeveloper/pyboomi-cli
+Project-URL: Documentation, https://github.com/iesoftwaredeveloper/pyboomi-cli#readme
+Project-URL: Repository, https://github.com/iesoftwaredeveloper/pyboomi-cli.git
+Project-URL: Bug Tracker, https://github.com/iesoftwaredeveloper/pyboomi-cli/issues
+Project-URL: Changelog, https://github.com/iesoftwaredeveloper/pyboomi-cli/blob/main/CHANGELOG.md
+Keywords: boomi,api,cli,integration,platform,etl,middleware
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyboomi_platform>=0.1.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0.0; extra == "dev"
+Requires-Dist: tox>=4.0.0; extra == "dev"
+Requires-Dist: build>=0.10.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Provides-Extra: lint
+Requires-Dist: black>=23.0.0; extra == "lint"
+Requires-Dist: flake8>=6.0.0; extra == "lint"
+Requires-Dist: mypy>=1.0.0; extra == "lint"
+Requires-Dist: isort>=5.12.0; extra == "lint"
+Provides-Extra: docs
+Requires-Dist: sphinx>=5.0.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.0.0; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints>=1.19.0; extra == "docs"
+Dynamic: license-file
+
+# pyboomi-cli
+
+Command-line interface for the Boomi Platform API.
+
+## Installation
+
+### For Development
+
+```bash
+# Clone the repository
+git clone https://github.com/iesoftwaredeveloper/pyboomi-cli
+cd pyboomi-cli
+
+# Install with development dependencies
+pip install -e .[dev]
+```
+
+### For Usage (when published)
+
+```bash
+pip install pyboomi-cli
+```
+
+### From Source
+
+```bash
+git clone https://github.com/iesoftwaredeveloper/pyboomi-cli
+cd pyboomi-cli
+pip install -e .
+```
+
+## Usage
+
+```bash
+# Get help (both entry points are available)
+boomi --help
+pyboomi --help
+
+# Query folders (folders alias is supported)
+boomi folder query --account-id YOUR_ACCOUNT_ID --username YOUR_USERNAME --api-token YOUR_API_TOKEN
+# or
+boomi folders query --account-id YOUR_ACCOUNT_ID --username YOUR_USERNAME --api-token YOUR_API_TOKEN
+
+# Filter folders by name and print verbose request/response
+boomi folder query --name "My Folder" --verbose
+
+# Filter folders with parent constraints
+boomi folder query --name "My Folder" --parent-id 0000-parent-id
+boomi folder query --name "My Folder" --parent-name "Parent Folder"
+boomi folder query --name "My Folder" --parent-path "/Root/Parent"
+
+# Create a folder (parent can be provided by id or name/path)
+boomi folder create --name "New Folder" --parent-id 0000-parent-id
+boomi folder create --name "New Folder" --parent-name "Parent Folder"
+boomi folder create --name "New Folder" --parent-name "Parent Folder" --parent-path "/Root/Parent"
+
+# Using environment variables
+export BOOMI_ACCT=your-account-id
+export BOOMI_USER=your-username
+export BOOMI_TOKEN=your-api-token
+boomi folder query
+
+# Get component XML (optionally include branch/version with ~)
+boomi component get 1234-abcd
+boomi component get 1234-abcd --branch-id 5678-branch --version 1.0
+
+# Get component metadata for a branch (json|yaml|text)
+boomi component metadata 1234-abcd --branch-id 5678-branch --output-format json
+
+# Create a packaged component
+boomi package create 1234-abcd --version 1.0.0 --notes "Initial package"
+
+# Query packaged components by component ID or version (supports xml)
+boomi package query --component-id 1234-abcd --package-version 1.0.0 --output-format xml
+
+# Query branches (filter by name or parent)
+boomi branch query --name "feature-x"
+
+# Create a new branch under a parent branch
+boomi branch create 1111-parent "feature-x"
+
+# Update a branch
+boomi branch update 2222-branch --name "feature-x-renamed" --ready
+
+# Delete a branch
+boomi branch delete 2222-branch
+```
+
+## Commands
+
+- `folder` — Manage Boomi folders (group command, alias: `folders`)
+  - Subcommands:
+    - `folder query` — Query and list folders (`--name`, `--parent-id`, `--parent-name`, `--parent-path`, `--verbose`)
+    - `folder create` — Create a folder (`--name` required; `--parent-id` or `--parent-name` required, with optional `--parent-path` to disambiguate; `--output-format` `json|yaml|text`)
+  - Common options: `--account-id`, `--username`, `--api-token`
+- `component` — Manage Boomi components (group command)
+  - Subcommands:
+    - `component get <component_id>` — Get component XML (`--branch-id`, `--version` optional; always returns XML)
+    - `component metadata <component_id>` — Get component metadata (`--branch-id` optional; `--output-format` `json|yaml|text`)
+  - Common options: `--account-id`, `--username`, `--api-token`
+- `package` — Manage Boomi packages (group command)
+  - Subcommands:
+    - `package create <component_id> --version <version>` — Create packaged component (`--notes`, `--branch-name`, `--output-format` `json|yaml|text|xml`)
+    - `package get <packaged_component_id>` — Get packaged component (`--output-format` `json|yaml|text|xml`)
+    - `package query` — Query packaged components (`--component-id`, `--package-version`, `--output-format` `json|yaml|text|xml`)
+  - Common options: `--account-id`, `--username`, `--api-token`
+- `branch` — Manage Boomi branches (group command)
+  - Subcommands:
+    - `branch get <branch_id>` — Get a branch
+    - `branch query` — Query branches (`--name`, `--parent-branch-id`, `--package-id`, `--ready`, `--output-format` `json|yaml|text`)
+    - `branch create <parent_branch_id> <branch_name>` — Create a branch (`--package-id`, `--output-format` `json|yaml|text`)
+    - `branch update <branch_id>` — Update a branch (`--name`, `--description`, `--ready/--not-ready`, `--output-format` `json|yaml|text`)
+    - `branch delete <branch_id>` — Delete a branch
+  - Common options: `--account-id`, `--username`, `--api-token`
+- `process` — Manage Boomi processes (alias: `processes`) — placeholder
+
+## Environment Variables
+
+- `BOOMI_ACCT`: Your Boomi account ID
+- `BOOMI_USER`: Your Boomi username (email)
+- `BOOMI_TOKEN`: Your Boomi API token
+- `BOOMI_AUTH`: Base64 encoded Basic Auth string (alternative to username/token)
+
+## Output Formats
+
+Many commands support `--output-format` with the following values:
+
+- `json` (default)
+- `yaml` (falls back to json if PyYAML is not installed)
+- `text` (simple key/value text)
+- `xml` (returns raw XML when requested; defaults to XML for `component get`)
+
+## Templates
+
+The `templates/` directory contains XML templates for various Boomi component types including:
+
+- **Processes**: Unit test harnesses and process templates
+- **Connectors**: Database, API, and file connectors
+- **Profiles**: JSON, XML, flat file, and database profiles
+- **Maps**: Data mapping templates and functions
+- **APIs**: API services and proxy configurations
+- **Scripts**: Process and map scripts
+- **Certificates**: Security certificate templates
+
+These templates provide standardized starting points for creating Boomi components. See [TEMPLATE_SYSTEM.md](TEMPLATE_SYSTEM.md) for detailed information about the template system and usage.
+
+## Documentation
+
+- [CHANGELOG.md](CHANGELOG.md) - Version history and release notes
+- [TEMPLATE_SYSTEM.md](TEMPLATE_SYSTEM.md) - Template system documentation
+- [TEMPLATES_STRUCTURE.md](TEMPLATES_STRUCTURE.md) - Template directory structure

pyboomi_cli-0.2.5.dist-info/RECORD

@@ -0,0 +1,11 @@
+pyboomi_cli/__init__.py,sha256=DDPpf2yYk4-AwHdhfDZPDe8Nvi2-Ca-4aNSMtPdPvKc,1824
+pyboomi_cli/cache.py,sha256=-FYcR1DeRos9bF3M9yEeOLYBlDsK1_RzD89TJNJhKLw,3677
+pyboomi_cli/cli.py,sha256=tmd7MS83o0EOZS0M-jfilZOj1Yg6sgZ6ZVB1FGaeECs,2218
+pyboomi_cli/config.py,sha256=JxlVQr43xrNWSwr18nLigKDVQ55Ughl0z0JD1Q3uDUQ,1438
+pyboomi_cli/utils.py,sha256=37u0CE2UWnBrZrcHSSJv5zrvCe5jeZ7eVVdxYHKgCvA,20286
+pyboomi_cli-0.2.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyboomi_cli-0.2.5.dist-info/METADATA,sha256=zApTduaWleJDFp8bg0n7VdTaNOcINIrZlpUSGT3Eb10,8657
+pyboomi_cli-0.2.5.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+pyboomi_cli-0.2.5.dist-info/entry_points.txt,sha256=qigTo4ZwZ5MVK5OfkpB75_i9_2_q36dPZsyqa-grsK0,78
+pyboomi_cli-0.2.5.dist-info/top_level.txt,sha256=hUdkMJxOXraWdexC9lBVRhSOs_XeN1q1ZGdFofQizF0,12
+pyboomi_cli-0.2.5.dist-info/RECORD,,

pyboomi_cli-0.2.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyboomi_cli-0.2.5.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+boomi = pyboomi_cli.cli:main
+pyboomi = pyboomi_cli.cli:main

pyboomi_cli-0.2.5.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

pyboomi_cli-0.2.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyboomi_cli