rhylthyme-cli-runner 0.1.0a0__py3-none-any.whl

rhylthyme_cli_runner/__init__.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""
+Rhylthyme CLI Runner Package
+
+This package provides the command-line interface for running and validating
+Rhylthyme real-time program schedules.
+"""
+
+__version__ = "0.1.0-alpha"
+__author__ = "Rhylthyme Team"
+__description__ = "CLI runner for Rhylthyme real-time program schedules"
+
+from .cli import cli, main
+
+__all__ = ['cli', 'main'] 

rhylthyme_cli_runner/cli.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+"""
+Command-line interface for Rhylthyme
+
+This module provides the command-line interface for the Rhylthyme package,
+allowing users to validate and run real-time program schedules.
+"""
+
+import os
+import sys
+import click
+import subprocess
+import pkg_resources
+from pathlib import Path
+from .validate_program import validate_program_file
+from .program_runner import run_program
+from .program_planner import plan_program
+from .environment_loader import EnvironmentLoader
+
+# Global environment loader instance
+_environment_loader = None
+
+def get_environment_loader(environments_dir=None):
+    """Get the environment loader instance, creating it if necessary."""
+    global _environment_loader
+    
+    if _environment_loader is None:
+        if environments_dir is None:
+            # Check for environment variable first
+            env_dir = os.environ.get('RHYLTHYME_ENVIRONMENTS_DIR')
+            if env_dir:
+                environments_dir = env_dir
+            else:
+                # Check for environments directory in current working directory
+                cwd_environments = Path.cwd() / "environments"
+                if cwd_environments.exists():
+                    environments_dir = str(cwd_environments)
+        
+        _environment_loader = EnvironmentLoader(environments_dir)
+    
+    return _environment_loader
+
+# Set up the main CLI group
+@click.group()
+@click.option('--environments-dir', type=click.Path(exists=True),
+              help='Directory containing environment files (default: check current directory, then package default)')
+@click.version_option()
+@click.pass_context
+def cli(ctx, environments_dir):
+    """
+    Rhylthyme - A tool for working with real-time program schedules.
+    
+    This CLI tool provides commands for validating and running real-time
+    program schedules defined using the Rhylthyme JSON or YAML schema.
+    """
+    # Store the environments directory in the context
+    ctx.ensure_object(dict)
+    ctx.obj['environments_dir'] = environments_dir
+    
+    # Initialize the environment loader
+    get_environment_loader(environments_dir)
+
+# Validate command
+@cli.command()
+@click.argument('program_file', type=click.Path(exists=True))
+@click.option('--schema', type=click.Path(exists=True), 
+              default=lambda: pkg_resources.resource_filename('rhylthyme_spec', 'schemas/program_schema_0.1.0-alpha.json'),
+              help='Path to the schema file (default: built-in schema)')
+@click.option('--verbose', '-v', is_flag=True, help='Show detailed validation information')
+@click.option('--json', '-j', 'json_output', is_flag=True, help='Print machine-readable JSON result')
+@click.option('--strict', '-s', is_flag=True, help='Enforce all tasks must be defined in resourceConstraints (strict mode)')
+def validate(program_file, schema, verbose, json_output, strict):
+    """
+    Validate a program file against the schema.
+    
+    This command checks if the provided program file (JSON or YAML) conforms to the
+    Rhylthyme schema and performs additional semantic validations.
+    
+    Use --json to get machine-readable output for CI or scripting.
+    Use --strict to require all tasks used in steps/buffers to be defined in resourceConstraints.
+    """
+    success = validate_program_file(program_file, schema, verbose, json_output, strict)
+    if not success:
+        sys.exit(1)
+
+# Run command
+@cli.command()
+@click.argument('program_file', type=click.Path(exists=True))
+@click.option('--schema', type=click.Path(exists=True), 
+              default=lambda: pkg_resources.resource_filename('rhylthyme_spec', 'schemas/program_schema_0.1.0-alpha.json'),
+              help='Path to the schema file (default: built-in schema)')
+@click.option('-e', '--environment', type=str,
+              help='Environment file path or ID to use (overrides program environment setting)')
+@click.option('--time-scale', type=float, default=1.0, 
+              help='Time scale factor (default: 1.0)')
+@click.option('--validate/--no-validate', default=True, 
+              help='Validate the program before running (default: True)')
+@click.option('--auto-start', is_flag=True, 
+              help='Automatically start the program without waiting for manual trigger')
+def run(program_file, schema, environment, time_scale, validate, auto_start):
+    """
+    Run a program file with the interactive UI.
+    
+    This command executes the provided program file (JSON or YAML) according to the
+    Rhylthyme schema and displays an interactive terminal UI for
+    monitoring and controlling the execution.
+    
+    Use -e/--environment to specify which environment to use when running the program.
+    This overrides any environment specified in the program file.
+    """
+    run_program(program_file, schema, time_scale, validate, auto_start, environment)
+
+# Plan command
+@cli.command()
+@click.argument('input_file', type=click.Path(exists=True))
+@click.argument('output_file', type=click.Path())
+@click.option('-e', '--environment', type=str, help='Environment file path to use for planning')
+@click.option('--verbose', '-v', is_flag=True, help='Show detailed planning information')
+def plan(input_file, output_file, environment, verbose):
+    """
+    Optimize a program schedule to reduce resource contention.
+    
+    This command analyzes the provided program file (JSON or YAML) for resource
+    bottlenecks and creates an optimized version by staggering track and step
+    starts to reduce contention at critical junctures.
+    
+    The optimized program is saved to the specified output file.
+    """
+    success = plan_program(input_file, output_file, verbose, environment_file=environment)
+    if not success:
+        sys.exit(1)
+    
+    click.echo(f"Optimized program saved to {output_file}")
+    click.echo("Run the optimized program with:")
+    click.echo(f"  rhylthyme run {output_file}")
+
+# Environments command
+@cli.command()
+@click.option('--format', '-f', type=click.Choice(['table', 'json', 'yaml']), default='table', 
+              help='Output format (default: table)')
+def environments(format):
+    """
+    List all available environment catalogs.
+    
+    This command displays all environment catalogs that can be referenced
+    by programs. Each environment defines resource constraints for different
+    settings like restaurants, bakeries, laboratories, etc.
+    """
+    loader = get_environment_loader()
+    envs = loader.list_environments()
+    
+    if not envs:
+        click.echo("No environment catalogs found.")
+        return
+    
+    if format == 'json':
+        import json
+        click.echo(json.dumps(envs, indent=2))
+    elif format == 'yaml':
+        import yaml
+        click.echo(yaml.dump(envs, default_flow_style=False))
+    else:  # table format
+        # Calculate column widths
+        id_width = max(len(env['id']) for env in envs) + 2
+        name_width = max(len(env['name']) for env in envs) + 2
+        type_width = max(len(env['type']) for env in envs) + 2
+        icon_width = max(len(env.get('icon', '')) for env in envs) + 2
+        
+        # Print header
+        click.echo(f"{'ID':<{id_width}}{'Name':<{name_width}}{'Type':<{type_width}}{'Icon':<{icon_width}}Description")
+        click.echo(f"{'-' * id_width}{'-' * name_width}{'-' * type_width}{'-' * icon_width}{'-' * 40}")
+        
+        # Print environments
+        for env in envs:
+            description = env['description']
+            if len(description) > 40:
+                description = description[:37] + "..."
+            icon = env.get('icon', 'fa-building')
+            click.echo(f"{env['id']:<{id_width}}{env['name']:<{name_width}}{env['type']:<{type_width}}{icon:<{icon_width}}{description}")
+
+# Validate environments command
+@cli.command('validate-environments')
+@click.option('--environments-dir', type=click.Path(exists=True), default='environments',
+              help='Directory containing environment files (default: environments)')
+@click.option('--verbose', '-v', is_flag=True, help='Show detailed validation information')
+def validate_environments(environments_dir, verbose):
+    """
+    Validate all environment catalog files against their schemas.
+    
+    This command checks if environment files conform to the base environment
+    schema and validates type-specific requirements (e.g., kitchen environments
+    should have appropriate kitchen tasks and equipment).
+    """
+    try:
+        from .environment_schemas import validate_all_environments, EnvironmentValidator
+    except ImportError:
+        click.echo("Error: Environment validation not available. Missing dependencies.")
+        sys.exit(1)
+    
+    click.echo(f"Validating environments in: {environments_dir}")
+    validation_results = validate_all_environments(environments_dir)
+    
+    if not validation_results:
+        click.echo("✓ All environment files are valid!")
+        return
+    
+    # Count errors vs warnings
+    total_errors = 0
+    total_warnings = 0
+    
+    for filename, errors in validation_results.items():
+        click.echo(f"\n{filename}:")
+        for error in errors:
+            if error.startswith("Warning:"):
+                total_warnings += 1
+                if verbose:
+                    click.echo(f"  ⚠️  {error}")
+            else:
+                total_errors += 1
+                click.echo(f"  ❌ {error}")
+    
+    if total_errors > 0:
+        click.echo(f"\n❌ Validation failed: {total_errors} errors found")
+        if total_warnings > 0:
+            click.echo(f"⚠️  {total_warnings} warnings found")
+        sys.exit(1)
+    elif total_warnings > 0:
+        click.echo(f"\n⚠️  Validation passed with {total_warnings} warnings")
+        if not verbose:
+            click.echo("Use --verbose to see warning details")
+    else:
+        click.echo("✓ All environment files are valid!")
+
+# Environment info command
+@cli.command('environment-info')
+@click.argument('environment_type')
+def environment_info(environment_type):
+    """
+    Show information about a specific environment type.
+    
+    This command displays the required tasks, common tasks, and suggested
+    actor types for a given environment type (e.g., kitchen, laboratory, bakery).
+    """
+    try:
+        from .environment_schemas import EnvironmentValidator
+        from .environment_icons import get_environment_icon
+    except ImportError:
+        click.echo("Error: Environment schemas not available.")
+        sys.exit(1)
+    
+    validator = EnvironmentValidator()
+    info = validator.get_environment_type_info(environment_type)
+    
+    if not info:
+        click.echo(f"Unknown environment type: {environment_type}")
+        click.echo(f"Supported types: {', '.join(sorted(validator.list_supported_types()))}")
+        sys.exit(1)
+    
+    # Get icon
+    icon = get_environment_icon(environment_type)
+    
+    click.echo(f"Environment Type: {environment_type}")
+    click.echo(f"Icon: {icon}")
+    click.echo(f"Required Tasks: {', '.join(info.get('required_tasks', []))}")
+    click.echo(f"Common Tasks: {', '.join(info.get('common_tasks', []))}")
+    click.echo(f"Actor Types: {', '.join(info.get('actor_types', []))}")
+
+def main():
+    """Entry point for the CLI."""
+    cli()
+
+if __name__ == '__main__':
+    main() 

rhylthyme_cli_runner/environment_icons.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""
+Environment Icons Index
+
+This module provides a mapping of environment types to appropriate FontAwesome icons
+for use in visualizations and user interfaces.
+"""
+
+from typing import Dict, List, Optional
+
+# Environment Types to FontAwesome Icons Mapping
+ENVIRONMENT_ICONS: Dict[str, str] = {
+    # Kitchen environments
+    "kitchen": "fa-utensils",
+    "home": "fa-house",
+    "restaurant": "fa-utensils",
+    "commercial-kitchen": "fa-fire-burner",
+    
+    # Laboratory environments
+    "laboratory": "fa-flask",
+    "lab": "fa-flask",
+    "research": "fa-microscope",
+    "biotech": "fa-dna",
+    "pharma": "fa-pills",
+    "medical": "fa-user-doctor",
+    
+    # Bakery environments
+    "bakery": "fa-bread-slice",
+    "artisan": "fa-wheat-awn",
+    "pastry": "fa-cake-candles",
+    
+    # Airport environments
+    "airport": "fa-plane",
+    "aviation": "fa-plane-departure",
+    "runway": "fa-plane-arrival",
+    "terminal": "fa-building",
+    
+    # Additional environment types
+    "manufacturing": "fa-industry",
+    "warehouse": "fa-warehouse",
+    "office": "fa-building",
+    "hospital": "fa-hospital",
+    "school": "fa-graduation-cap",
+    "retail": "fa-store",
+    "farm": "fa-tractor",
+    "datacenter": "fa-server",
+    "factory": "fa-gear",
+    "workshop": "fa-screwdriver-wrench",
+    "garage": "fa-car",
+    "gym": "fa-dumbbell",
+    "studio": "fa-microphone",
+    "theater": "fa-masks-theater",
+    "library": "fa-book",
+    "garden": "fa-seedling",
+    "greenhouse": "fa-leaf",
+    "clinic": "fa-stethoscope",
+    "spa": "fa-spa",
+    "hotel": "fa-bed",
+}
+
+# Default icon for unknown environment types
+DEFAULT_ENVIRONMENT_ICON = "fa-building"
+
+# Icon categories for organization
+ICON_CATEGORIES: Dict[str, List[str]] = {
+    "food_service": [
+        "kitchen", "restaurant", "commercial-kitchen", "bakery", 
+        "artisan", "pastry", "home"
+    ],
+    "research_science": [
+        "laboratory", "lab", "research", "biotech", "pharma", "medical"
+    ],
+    "transportation": [
+        "airport", "aviation", "runway", "terminal"
+    ],
+    "industrial": [
+        "manufacturing", "warehouse", "factory", "workshop", "garage"
+    ],
+    "commercial": [
+        "office", "retail", "store", "hotel"
+    ],
+    "healthcare": [
+        "hospital", "clinic", "spa"
+    ],
+    "educational": [
+        "school", "library"
+    ],
+    "entertainment": [
+        "gym", "studio", "theater"
+    ],
+    "agricultural": [
+        "farm", "garden", "greenhouse"
+    ],
+    "technology": [
+        "datacenter"
+    ]
+}
+
+
+def get_environment_icon(environment_type: str) -> str:
+    """
+    Get the FontAwesome icon class for a given environment type.
+    
+    Args:
+        environment_type: The type of environment (e.g., 'kitchen', 'laboratory')
+        
+    Returns:
+        FontAwesome icon class string (e.g., 'fa-utensils')
+    """
+    if not environment_type:
+        return DEFAULT_ENVIRONMENT_ICON
+    
+    # Normalize the environment type (lowercase, handle common variations)
+    normalized_type = environment_type.lower().strip()
+    
+    # Direct lookup
+    if normalized_type in ENVIRONMENT_ICONS:
+        return ENVIRONMENT_ICONS[normalized_type]
+    
+    # Try partial matches for compound names
+    for env_type, icon in ENVIRONMENT_ICONS.items():
+        if env_type in normalized_type or normalized_type in env_type:
+            return icon
+    
+    # Return default if no match found
+    return DEFAULT_ENVIRONMENT_ICON
+
+
+def get_environment_icon_with_prefix(environment_type: str, prefix: str = "fas") -> str:
+    """
+    Get the complete FontAwesome icon class with prefix for a given environment type.
+    
+    Args:
+        environment_type: The type of environment
+        prefix: FontAwesome prefix (e.g., 'fas', 'far', 'fab')
+        
+    Returns:
+        Complete FontAwesome icon class string (e.g., 'fas fa-utensils')
+    """
+    icon = get_environment_icon(environment_type)
+    return f"{prefix} {icon}"
+
+
+def get_icon_category(environment_type: str) -> Optional[str]:
+    """
+    Get the category that an environment type belongs to.
+    
+    Args:
+        environment_type: The type of environment
+        
+    Returns:
+        Category name or None if not found
+    """
+    normalized_type = environment_type.lower().strip() if environment_type else ""
+    
+    for category, types in ICON_CATEGORIES.items():
+        if normalized_type in types:
+            return category
+    
+    return None
+
+
+def list_environment_types() -> List[str]:
+    """
+    Get a list of all supported environment types.
+    
+    Returns:
+        List of environment type strings
+    """
+    return list(ENVIRONMENT_ICONS.keys())
+
+
+def list_environment_types_by_category() -> Dict[str, List[str]]:
+    """
+    Get all environment types organized by category.
+    
+    Returns:
+        Dictionary mapping category names to lists of environment types
+    """
+    return ICON_CATEGORIES.copy()
+
+
+def search_environment_types(query: str) -> List[str]:
+    """
+    Search for environment types that match a query string.
+    
+    Args:
+        query: Search query string
+        
+    Returns:
+        List of matching environment types
+    """
+    query_lower = query.lower().strip()
+    matches = []
+    
+    for env_type in ENVIRONMENT_ICONS.keys():
+        if query_lower in env_type.lower():
+            matches.append(env_type)
+    
+    return sorted(matches)
+
+
+# Validation function to ensure all referenced icons exist in FontAwesome
+def validate_icons() -> Dict[str, bool]:
+    """
+    Validate that all icons in the mapping are valid FontAwesome icons.
+    Note: This is a basic check based on common FontAwesome patterns.
+    For complete validation, you would need to check against the FontAwesome icon list.
+    
+    Returns:
+        Dictionary mapping icon names to validation status
+    """
+    validation_results = {}
+    
+    # Common FontAwesome icon patterns for basic validation
+    valid_patterns = [
+        "fa-", "fa-solid", "fa-regular", "fa-light", "fa-thin", "fa-duotone", "fa-brands"
+    ]
+    
+    for env_type, icon in ENVIRONMENT_ICONS.items():
+        # Basic validation: check if it starts with fa-
+        is_valid = icon.startswith("fa-") and len(icon) > 3
+        validation_results[icon] = is_valid
+    
+    return validation_results
+
+
+if __name__ == "__main__":
+    # Example usage and testing
+    print("Environment Icons Index")
+    print("=" * 40)
+    
+    # Test the specific environment types requested
+    test_types = ["kitchen", "laboratory", "bakery", "airport"]
+    
+    print("\nRequested Environment Types:")
+    for env_type in test_types:
+        icon = get_environment_icon(env_type)
+        full_icon = get_environment_icon_with_prefix(env_type)
+        category = get_icon_category(env_type)
+        print(f"  {env_type:12} -> {icon:20} ({full_icon}) [Category: {category}]")
+    
+    print(f"\nTotal supported environment types: {len(list_environment_types())}")
+    
+    print("\nEnvironment Types by Category:")
+    for category, types in list_environment_types_by_category().items():
+        print(f"  {category:15}: {', '.join(types)}")
+    
+    print(f"\nDefault icon: {DEFAULT_ENVIRONMENT_ICON}")
+    
+    # Icon validation
+    print("\nIcon Validation Results:")
+    validation = validate_icons()
+    invalid_icons = [icon for icon, valid in validation.items() if not valid]
+    if invalid_icons:
+        print(f"  Invalid icons found: {invalid_icons}")
+    else:
+        print("  All icons appear to be valid FontAwesome patterns")