502 lines
14 KiB
Python
502 lines
14 KiB
Python
"""
|
|
Conditional Prompt Template
|
|
|
|
Use for: Dynamic forms based on previous answers
|
|
Features: Skip logic, dependent questions, branching
|
|
"""
|
|
|
|
import questionary
|
|
from questionary import Choice, Separator
|
|
|
|
|
|
def conditional_prompt_example():
|
|
"""Example conditional prompts"""
|
|
|
|
print("\n🔀 Conditional Prompt Example\n")
|
|
|
|
# First question: Use database?
|
|
use_database = questionary.confirm(
|
|
"Do you want to use a database?",
|
|
default=True
|
|
).ask()
|
|
|
|
database_config = {}
|
|
|
|
if use_database:
|
|
# Database type
|
|
database_type = questionary.select(
|
|
"Select database type:",
|
|
choices=['PostgreSQL', 'MySQL', 'MongoDB', 'SQLite', 'Redis']
|
|
).ask()
|
|
|
|
database_config['databaseType'] = database_type
|
|
|
|
# Host and port (not for SQLite)
|
|
if database_type != 'SQLite':
|
|
database_host = questionary.text(
|
|
"Database host:",
|
|
default="localhost"
|
|
).ask()
|
|
|
|
# Default ports based on database type
|
|
default_ports = {
|
|
'PostgreSQL': '5432',
|
|
'MySQL': '3306',
|
|
'MongoDB': '27017',
|
|
'Redis': '6379'
|
|
}
|
|
|
|
database_port = questionary.text(
|
|
"Database port:",
|
|
default=default_ports.get(database_type, '5432')
|
|
).ask()
|
|
|
|
database_config['host'] = database_host
|
|
database_config['port'] = database_port
|
|
|
|
# Database name
|
|
database_name = questionary.text(
|
|
"Database name:",
|
|
validate=lambda text: len(text) > 0 or "Database name required"
|
|
).ask()
|
|
|
|
database_config['databaseName'] = database_name
|
|
|
|
# Authentication
|
|
use_authentication = questionary.confirm(
|
|
"Do you want to use authentication?",
|
|
default=True
|
|
).ask()
|
|
|
|
if use_authentication:
|
|
database_username = questionary.text(
|
|
"Database username:",
|
|
validate=lambda text: len(text) > 0 or "Username required"
|
|
).ask()
|
|
|
|
database_password = questionary.password(
|
|
"Database password:"
|
|
).ask()
|
|
|
|
database_config['useAuthentication'] = True
|
|
database_config['username'] = database_username
|
|
# Don't store actual password in answers
|
|
|
|
# SSL (only for remote hosts)
|
|
if database_type != 'SQLite' and database_config.get('host') != 'localhost':
|
|
use_ssl = questionary.confirm(
|
|
"Use SSL connection?",
|
|
default=False
|
|
).ask()
|
|
|
|
if use_ssl:
|
|
ssl_cert_path = questionary.text(
|
|
"Path to SSL certificate:",
|
|
validate=lambda text: len(text) > 0 or "SSL certificate path required"
|
|
).ask()
|
|
|
|
database_config['useSSL'] = True
|
|
database_config['sslCertPath'] = ssl_cert_path
|
|
|
|
answers = {
|
|
'useDatabase': use_database,
|
|
'databaseConfig': database_config if use_database else None
|
|
}
|
|
|
|
print("\n✅ Configuration:")
|
|
import json
|
|
print(json.dumps(answers, indent=2))
|
|
|
|
return answers
|
|
|
|
|
|
def deployment_wizard():
|
|
"""Example: Deployment configuration wizard"""
|
|
|
|
print("\n🚀 Deployment Configuration Wizard\n")
|
|
|
|
# Environment
|
|
environment = questionary.select(
|
|
"Select deployment environment:",
|
|
choices=['Development', 'Staging', 'Production']
|
|
).ask()
|
|
|
|
config = {'environment': environment}
|
|
|
|
# Docker
|
|
use_docker = questionary.confirm(
|
|
"Deploy using Docker?",
|
|
default=True
|
|
).ask()
|
|
|
|
config['useDocker'] = use_docker
|
|
|
|
if use_docker:
|
|
docker_image = questionary.text(
|
|
"Docker image name:",
|
|
default="myapp:latest",
|
|
validate=lambda text: len(text) > 0 or "Docker image name required"
|
|
).ask()
|
|
|
|
config['dockerImage'] = docker_image
|
|
|
|
registry = questionary.select(
|
|
"Container registry:",
|
|
choices=[
|
|
'Docker Hub',
|
|
'GitHub Container Registry',
|
|
'AWS ECR',
|
|
'Google Artifact Registry'
|
|
]
|
|
).ask()
|
|
|
|
config['registry'] = registry
|
|
|
|
# Platform
|
|
platform = questionary.select(
|
|
"Deployment platform:",
|
|
choices=[
|
|
'AWS', 'Google Cloud', 'Azure',
|
|
'DigitalOcean', 'Vercel', 'Netlify', 'Self-hosted'
|
|
]
|
|
).ask()
|
|
|
|
config['platform'] = platform
|
|
|
|
# Platform-specific configuration
|
|
if platform == 'AWS':
|
|
aws_service = questionary.select(
|
|
"AWS service:",
|
|
choices=['ECS', 'EKS', 'Lambda', 'Elastic Beanstalk', 'EC2']
|
|
).ask()
|
|
config['awsService'] = aws_service
|
|
|
|
# Auto-scaling (only for certain services)
|
|
if aws_service in ['ECS', 'EKS']:
|
|
auto_scale = questionary.confirm(
|
|
"Enable auto-scaling?",
|
|
default=True
|
|
).ask()
|
|
|
|
config['autoScale'] = auto_scale
|
|
|
|
if auto_scale:
|
|
min_instances = questionary.text(
|
|
"Minimum instances:",
|
|
default="1",
|
|
validate=lambda text: text.isdigit() and int(text) > 0 or "Must be at least 1"
|
|
).ask()
|
|
|
|
max_instances = questionary.text(
|
|
"Maximum instances:",
|
|
default="10",
|
|
validate=lambda text: text.isdigit() and int(text) >= int(min_instances) or f"Must be at least {min_instances}"
|
|
).ask()
|
|
|
|
config['minInstances'] = int(min_instances)
|
|
config['maxInstances'] = int(max_instances)
|
|
|
|
elif platform == 'Google Cloud':
|
|
gcp_service = questionary.select(
|
|
"Google Cloud service:",
|
|
choices=['Cloud Run', 'GKE', 'App Engine', 'Compute Engine']
|
|
).ask()
|
|
config['gcpService'] = gcp_service
|
|
|
|
# CDN (only for production)
|
|
if environment == 'Production':
|
|
use_cdn = questionary.confirm(
|
|
"Use CDN for static assets?",
|
|
default=True
|
|
).ask()
|
|
|
|
config['useCDN'] = use_cdn
|
|
|
|
if use_cdn:
|
|
cdn_provider = questionary.select(
|
|
"CDN provider:",
|
|
choices=['CloudFlare', 'AWS CloudFront', 'Google Cloud CDN', 'Azure CDN']
|
|
).ask()
|
|
config['cdnProvider'] = cdn_provider
|
|
|
|
# Monitoring
|
|
setup_monitoring = questionary.confirm(
|
|
"Setup monitoring?",
|
|
default=True
|
|
).ask()
|
|
|
|
if setup_monitoring:
|
|
monitoring_tools = questionary.checkbox(
|
|
"Select monitoring tools:",
|
|
choices=['Prometheus', 'Grafana', 'Datadog', 'New Relic', 'Sentry'],
|
|
validate=lambda choices: len(choices) > 0 or "Select at least one tool"
|
|
).ask()
|
|
|
|
config['monitoringTools'] = monitoring_tools
|
|
|
|
print("\n✅ Deployment configuration complete!")
|
|
import json
|
|
print(json.dumps(config, indent=2))
|
|
|
|
return config
|
|
|
|
|
|
def feature_flag_wizard():
|
|
"""Example: Feature flag configuration"""
|
|
|
|
print("\n🎛️ Feature Flag Configuration\n")
|
|
|
|
# Feature name
|
|
feature_name = questionary.text(
|
|
"Feature name:",
|
|
validate=lambda text: text and text.replace('-', '').replace('_', '').islower() or "Use lowercase, hyphens, underscores only"
|
|
).ask()
|
|
|
|
# Enabled by default
|
|
enabled_by_default = questionary.confirm(
|
|
"Enabled by default?",
|
|
default=False
|
|
).ask()
|
|
|
|
config = {
|
|
'featureName': feature_name,
|
|
'enabledByDefault': enabled_by_default
|
|
}
|
|
|
|
# Rollout strategy
|
|
rollout_strategy = questionary.select(
|
|
"Rollout strategy:",
|
|
choices=[
|
|
'All users',
|
|
'Percentage rollout',
|
|
'User targeting',
|
|
'Beta users only',
|
|
'Manual control'
|
|
]
|
|
).ask()
|
|
|
|
config['rolloutStrategy'] = rollout_strategy
|
|
|
|
# Percentage rollout
|
|
if rollout_strategy == 'Percentage rollout':
|
|
rollout_percentage = questionary.text(
|
|
"Rollout percentage (0-100):",
|
|
default="10",
|
|
validate=lambda text: text.isdigit() and 0 <= int(text) <= 100 or "Must be between 0 and 100"
|
|
).ask()
|
|
|
|
config['rolloutPercentage'] = int(rollout_percentage)
|
|
|
|
# User targeting
|
|
if rollout_strategy == 'User targeting':
|
|
target_user_groups = questionary.checkbox(
|
|
"Target user groups:",
|
|
choices=[
|
|
'Beta testers',
|
|
'Premium users',
|
|
'Internal team',
|
|
'Early adopters',
|
|
'Specific regions'
|
|
],
|
|
validate=lambda choices: len(choices) > 0 or "Select at least one group"
|
|
).ask()
|
|
|
|
config['targetUserGroups'] = target_user_groups
|
|
|
|
# Specific regions
|
|
if 'Specific regions' in target_user_groups:
|
|
target_regions = questionary.checkbox(
|
|
"Target regions:",
|
|
choices=[
|
|
'North America',
|
|
'Europe',
|
|
'Asia Pacific',
|
|
'South America',
|
|
'Africa'
|
|
]
|
|
).ask()
|
|
|
|
config['targetRegions'] = target_regions
|
|
|
|
# Metrics
|
|
enable_metrics = questionary.confirm(
|
|
"Track feature usage metrics?",
|
|
default=True
|
|
).ask()
|
|
|
|
if enable_metrics:
|
|
metrics = questionary.checkbox(
|
|
"Select metrics to track:",
|
|
choices=[
|
|
'Usage count',
|
|
'User adoption rate',
|
|
'Performance impact',
|
|
'Error rate',
|
|
'User feedback'
|
|
]
|
|
).ask()
|
|
|
|
config['metrics'] = metrics
|
|
|
|
# Expiration
|
|
add_expiration_date = questionary.confirm(
|
|
"Set feature flag expiration?",
|
|
default=False
|
|
).ask()
|
|
|
|
if add_expiration_date:
|
|
expiration_date = questionary.text(
|
|
"Expiration date (YYYY-MM-DD):",
|
|
validate=lambda text: len(text) == 10 and text.count('-') == 2 or "Use format YYYY-MM-DD"
|
|
).ask()
|
|
|
|
config['expirationDate'] = expiration_date
|
|
|
|
print("\n✅ Feature flag configured!")
|
|
import json
|
|
print(json.dumps(config, indent=2))
|
|
|
|
return config
|
|
|
|
|
|
def cicd_pipeline_wizard():
|
|
"""Example: CI/CD pipeline setup"""
|
|
|
|
print("\n⚙️ CI/CD Pipeline Configuration\n")
|
|
|
|
# Provider
|
|
provider = questionary.select(
|
|
"CI/CD provider:",
|
|
choices=['GitHub Actions', 'GitLab CI', 'CircleCI', 'Jenkins', 'Travis CI']
|
|
).ask()
|
|
|
|
config = {'provider': provider}
|
|
|
|
# Triggers
|
|
triggers = questionary.checkbox(
|
|
"Pipeline triggers:",
|
|
choices=[
|
|
'Push to main/master',
|
|
'Pull request',
|
|
'Tag creation',
|
|
'Manual trigger',
|
|
'Scheduled (cron)'
|
|
],
|
|
default=['Push to main/master', 'Pull request']
|
|
).ask()
|
|
|
|
config['triggers'] = triggers
|
|
|
|
# Cron schedule
|
|
if 'Scheduled (cron)' in triggers:
|
|
cron_schedule = questionary.text(
|
|
"Cron schedule:",
|
|
default="0 2 * * *",
|
|
validate=lambda text: len(text.split()) == 5 or "Invalid cron format (5 parts required)"
|
|
).ask()
|
|
|
|
config['cronSchedule'] = cron_schedule
|
|
|
|
# Stages
|
|
stages = questionary.checkbox(
|
|
"Pipeline stages:",
|
|
choices=['Build', 'Test', 'Lint', 'Security scan', 'Deploy'],
|
|
default=['Build', 'Test', 'Deploy'],
|
|
validate=lambda choices: len(choices) > 0 or "Select at least one stage"
|
|
).ask()
|
|
|
|
config['stages'] = stages
|
|
|
|
# Test types
|
|
if 'Test' in stages:
|
|
test_types = questionary.checkbox(
|
|
"Test types to run:",
|
|
choices=[
|
|
'Unit tests',
|
|
'Integration tests',
|
|
'E2E tests',
|
|
'Performance tests'
|
|
]
|
|
).ask()
|
|
|
|
config['testTypes'] = test_types
|
|
|
|
# Security tools
|
|
if 'Security scan' in stages:
|
|
security_tools = questionary.checkbox(
|
|
"Security scanning tools:",
|
|
choices=['Snyk', 'Dependabot', 'SonarQube', 'OWASP Dependency Check']
|
|
).ask()
|
|
|
|
config['securityTools'] = security_tools
|
|
|
|
# Deploy environments
|
|
if 'Deploy' in stages:
|
|
deploy_environments = questionary.checkbox(
|
|
"Deployment environments:",
|
|
choices=['Development', 'Staging', 'Production'],
|
|
default=['Staging', 'Production']
|
|
).ask()
|
|
|
|
config['deployEnvironments'] = deploy_environments
|
|
|
|
# Approval for production
|
|
if 'Production' in deploy_environments:
|
|
require_approval = questionary.confirm(
|
|
"Require manual approval for production?",
|
|
default=True
|
|
).ask()
|
|
|
|
config['requireApproval'] = require_approval
|
|
|
|
# Notifications
|
|
enable_notifications = questionary.confirm(
|
|
"Enable build notifications?",
|
|
default=True
|
|
).ask()
|
|
|
|
if enable_notifications:
|
|
notification_channels = questionary.checkbox(
|
|
"Notification channels:",
|
|
choices=['Email', 'Slack', 'Discord', 'Microsoft Teams']
|
|
).ask()
|
|
|
|
config['notificationChannels'] = notification_channels
|
|
|
|
print("\n✅ CI/CD pipeline configured!")
|
|
import json
|
|
print(json.dumps(config, indent=2))
|
|
|
|
return config
|
|
|
|
|
|
def main():
|
|
"""Run conditional prompt examples"""
|
|
try:
|
|
print("=== Conditional Prompt Examples ===")
|
|
|
|
# Example 1: Database configuration
|
|
conditional_prompt_example()
|
|
|
|
# Example 2: Deployment wizard
|
|
deployment_wizard()
|
|
|
|
# Example 3: Feature flag configuration
|
|
feature_flag_wizard()
|
|
|
|
# Example 4: CI/CD pipeline setup
|
|
cicd_pipeline_wizard()
|
|
|
|
print("\n✅ Conditional prompt examples complete!")
|
|
|
|
except KeyboardInterrupt:
|
|
print("\n\n❌ User interrupted prompt")
|
|
exit(1)
|
|
except Exception as e:
|
|
print(f"\n\n❌ Error: {e}")
|
|
exit(1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|